Process.CancelErrorRead Method
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Cancels the asynchronous read operation on the redirected StandardError stream of an application.
public:
void CancelErrorRead();public void CancelErrorRead ();[System.Runtime.InteropServices.ComVisible(false)]
public void CancelErrorRead ();member this.CancelErrorRead : unit -> unit[<System.Runtime.InteropServices.ComVisible(false)>]
member this.CancelErrorRead : unit -> unitPublic Sub CancelErrorRead ()- Attributes
Exceptions
The StandardError stream is not enabled for asynchronous read operations.
Examples
The following example starts the nmake command with user supplied arguments. The error and output streams are read asynchronously; the collected text lines are displayed to the console as well as written to a log file. If the command output exceeds a specified number of lines, the asynchronous read operations are canceled.
ref class ProcessNMakeStreamRedirection
{
private:
// Define static variables shared by class methods.
static StreamWriter^ buildLogStream = nullptr;
static Mutex^ logMutex = gcnew Mutex;
static int maxLogLines = 25;
static int currentLogLines = 0;
public:
static void RedirectNMakeCommandStreams()
{
String^ nmakeArguments = nullptr;
Process^ nmakeProcess;
// Get the input nmake command-line arguments.
Console::WriteLine( "Enter the NMake command line arguments (@commandfile or /f makefile, etc):" );
String^ inputText = Console::ReadLine();
if ( !String::IsNullOrEmpty( inputText ) )
{
nmakeArguments = inputText;
}
Console::WriteLine( "Enter max line limit for log file (default is 25):" );
inputText = Console::ReadLine();
if ( !String::IsNullOrEmpty( inputText ) )
{
if ( !Int32::TryParse( inputText, maxLogLines ) )
{
maxLogLines = 25;
}
}
Console::WriteLine( "Output beyond {0} lines will be ignored.",
maxLogLines.ToString() );
// Initialize the process and its StartInfo properties.
nmakeProcess = gcnew Process;
nmakeProcess->StartInfo->FileName = "NMake.exe";
// Build the nmake command argument list.
if ( !String::IsNullOrEmpty( nmakeArguments ) )
{
nmakeProcess->StartInfo->Arguments = nmakeArguments;
}
// Set UseShellExecute to false for redirection.
nmakeProcess->StartInfo->UseShellExecute = false;
// Redirect the standard output of the nmake command.
// Read the stream asynchronously using an event handler.
nmakeProcess->StartInfo->RedirectStandardOutput = true;
nmakeProcess->OutputDataReceived += gcnew DataReceivedEventHandler( NMakeOutputDataHandler );
// Redirect the error output of the nmake command.
nmakeProcess->StartInfo->RedirectStandardError = true;
nmakeProcess->ErrorDataReceived += gcnew DataReceivedEventHandler( NMakeErrorDataHandler );
logMutex->WaitOne();
currentLogLines = 0;
// Write a header to the log file.
String^ buildLogFile = "NmakeCmd.Txt";
try
{
buildLogStream = gcnew StreamWriter( buildLogFile,true );
}
catch ( Exception^ e )
{
Console::WriteLine( "Could not open output file {0}", buildLogFile );
Console::WriteLine( "Exception = {0}", e->ToString() );
Console::WriteLine( e->Message->ToString() );
buildLogStream = nullptr;
}
if ( buildLogStream != nullptr )
{
Console::WriteLine( "Nmake output logged to {0}", buildLogFile );
buildLogStream->WriteLine();
buildLogStream->WriteLine( DateTime::Now.ToString() );
if ( !String::IsNullOrEmpty( nmakeArguments ) )
{
buildLogStream->Write( "Command line = NMake {0}", nmakeArguments );
}
else
{
buildLogStream->Write( "Command line = Nmake" );
}
buildLogStream->WriteLine();
buildLogStream->Flush();
logMutex->ReleaseMutex();
// Start the process.
Console::WriteLine();
Console::WriteLine( "\nStarting Nmake command" );
Console::WriteLine();
nmakeProcess->Start();
// Start the asynchronous read of the output stream.
nmakeProcess->BeginOutputReadLine();
// Start the asynchronous read of the error stream.
nmakeProcess->BeginErrorReadLine();
// Let the nmake command run, collecting the output.
nmakeProcess->WaitForExit();
nmakeProcess->Close();
buildLogStream->Close();
logMutex->Dispose();
}
}
private:
static void NMakeOutputDataHandler( Object^ sendingProcess,
DataReceivedEventArgs^ outLine )
{
// Collect the output, displaying it to the screen and
// logging it to the output file. Cancel the read
// operation when the maximum line limit is reached.
if ( !String::IsNullOrEmpty( outLine->Data ) )
{
logMutex->WaitOne();
currentLogLines++;
if ( currentLogLines > maxLogLines )
{
// Display the line to the console.
// Skip writing the line to the log file.
Console::WriteLine( "StdOut: {0}", outLine->Data->ToString() );
}
else
if ( currentLogLines == maxLogLines )
{
LogToFile( "StdOut", "<Max build log limit reached!>", true );
// Stop reading the output streams.
Process^ p = dynamic_cast<Process^>(sendingProcess);
if ( p != nullptr )
{
p->CancelOutputRead();
p->CancelErrorRead();
}
}
else
{
// Write the line to the log file.
LogToFile( "StdOut", outLine->Data, true );
}
logMutex->ReleaseMutex();
}
}
static void NMakeErrorDataHandler( Object^ sendingProcess,
DataReceivedEventArgs^ errLine )
{
// Collect the error output, displaying it to the screen and
// logging it to the output file. Cancel the error output
// read operation when the maximum line limit is reached.
if ( !String::IsNullOrEmpty( errLine->Data ) )
{
logMutex->WaitOne();
currentLogLines++;
if ( currentLogLines > maxLogLines )
{
// Display the line to the console.
// Skip writing the line to the log file.
Console::WriteLine( "StdErr: {0}", errLine->Data->ToString() );
}
else
if ( currentLogLines == maxLogLines )
{
LogToFile( "StdOut", "<Max build log limit reached!>", true );
// Stop reading the output streams.
Process^ p = dynamic_cast<Process^>(sendingProcess);
if ( p != nullptr )
{
p->CancelOutputRead();
p->CancelErrorRead();
}
}
else
{
// Write the line to the log file.
LogToFile( "StdErr", errLine->Data, true );
}
logMutex->ReleaseMutex();
}
}
static void LogToFile( String^ logPrefix, String^ logText,
bool echoToConsole )
{
// Write the specified line to the log file stream.
StringBuilder^ logString = gcnew StringBuilder;
if ( !String::IsNullOrEmpty( logPrefix ) )
{
logString->AppendFormat( "{0}> ", logPrefix );
}
if ( !String::IsNullOrEmpty( logText ) )
{
logString->Append( logText );
}
if ( buildLogStream != nullptr )
{
buildLogStream->WriteLine( "[{0}] {1}",
DateTime::Now.ToString(), logString->ToString() );
buildLogStream->Flush();
}
if ( echoToConsole )
{
Console::WriteLine( logString->ToString() );
}
}
};
namespace ProcessAsyncStreamSamples
{
class ProcessNMakeStreamRedirection
{
// Define static variables shared by class methods.
private static StreamWriter buildLogStream =null;
private static Mutex logMutex = new Mutex();
private static int maxLogLines = 25;
private static int currentLogLines = 0;
public static void RedirectNMakeCommandStreams()
{
String nmakeArguments = null;
Process nmakeProcess;
// Get the input nmake command-line arguments.
Console.WriteLine("Enter the NMake command line arguments " +
"(@commandfile or /f makefile, etc):");
String inputText = Console.ReadLine();
if (!String.IsNullOrEmpty(inputText))
{
nmakeArguments = inputText;
}
Console.WriteLine("Enter max line limit for log file (default is 25):");
inputText = Console.ReadLine();
if (!String.IsNullOrEmpty(inputText))
{
if (!Int32.TryParse(inputText, out maxLogLines))
{
maxLogLines = 25;
}
}
Console.WriteLine("Output beyond {0} lines will be ignored.",
maxLogLines);
// Initialize the process and its StartInfo properties.
nmakeProcess = new Process();
nmakeProcess.StartInfo.FileName = "NMake.exe";
// Build the nmake command argument list.
if (!String.IsNullOrEmpty(nmakeArguments))
{
nmakeProcess.StartInfo.Arguments = nmakeArguments;
}
// Set UseShellExecute to false for redirection.
nmakeProcess.StartInfo.UseShellExecute = false;
// Redirect the standard output of the nmake command.
// Read the stream asynchronously using an event handler.
nmakeProcess.StartInfo.RedirectStandardOutput = true;
nmakeProcess.OutputDataReceived += new DataReceivedEventHandler(NMakeOutputDataHandler);
// Redirect the error output of the nmake command.
nmakeProcess.StartInfo.RedirectStandardError = true;
nmakeProcess.ErrorDataReceived += new DataReceivedEventHandler(NMakeErrorDataHandler);
logMutex.WaitOne();
currentLogLines = 0;
// Write a header to the log file.
const String buildLogFile = "NmakeCmd.Txt";
try
{
buildLogStream = new StreamWriter(buildLogFile, true);
}
catch (Exception e)
{
Console.WriteLine("Could not open output file {0}", buildLogFile);
Console.WriteLine("Exception = {0}", e.ToString());
Console.WriteLine(e.Message);
buildLogStream = null;
}
if (buildLogStream != null)
{
Console.WriteLine("Nmake output logged to {0}",
buildLogFile);
buildLogStream.WriteLine();
buildLogStream.WriteLine(DateTime.Now.ToString());
if (!String.IsNullOrEmpty(nmakeArguments))
{
buildLogStream.Write("Command line = NMake {0}",
nmakeArguments);
}
else
{
buildLogStream.Write("Command line = Nmake");
}
buildLogStream.WriteLine();
buildLogStream.Flush();
logMutex.ReleaseMutex();
// Start the process.
Console.WriteLine();
Console.WriteLine("\nStarting Nmake command...");
Console.WriteLine();
nmakeProcess.Start();
// Start the asynchronous read of the error stream.
nmakeProcess.BeginErrorReadLine();
// Start the asynchronous read of the output stream.
nmakeProcess.BeginOutputReadLine();
// Let the nmake command run, collecting the output.
nmakeProcess.WaitForExit();
nmakeProcess.Close();
buildLogStream.Close();
logMutex.Dispose();
}
}
private static void NMakeOutputDataHandler(object sendingProcess,
DataReceivedEventArgs outLine)
{
// Collect the output, displaying it to the screen and
// logging it to the output file. Cancel the read
// operation when the maximum line limit is reached.
if (!String.IsNullOrEmpty(outLine.Data))
{
logMutex.WaitOne();
currentLogLines++;
if (currentLogLines > maxLogLines)
{
// Display the line to the console.
// Skip writing the line to the log file.
Console.WriteLine("StdOut: {0}", outLine.Data);
}
else if (currentLogLines == maxLogLines)
{
LogToFile("StdOut", "<Max build log limit reached!>",
true);
// Stop reading the output streams.
Process p = sendingProcess as Process;
if (p != null)
{
p.CancelOutputRead();
p.CancelErrorRead();
}
}
else
{
// Write the line to the log file.
LogToFile("StdOut", outLine.Data, true);
}
logMutex.ReleaseMutex();
}
}
private static void NMakeErrorDataHandler(object sendingProcess,
DataReceivedEventArgs errLine)
{
// Collect error output, displaying it to the screen and
// logging it to the output file. Cancel the error output
// read operation when the maximum line limit is reached.
if (!String.IsNullOrEmpty(errLine.Data))
{
logMutex.WaitOne();
currentLogLines++;
if (currentLogLines > maxLogLines)
{
// Display the error line to the console.
// Skip writing the line to the log file.
Console.WriteLine("StdErr: {0}", errLine.Data);
}
else if (currentLogLines == maxLogLines)
{
LogToFile("StdErr", "<Max build log limit reached!>",
true);
// Stop reading the output streams
Process p = sendingProcess as Process;
if (p != null)
{
p.CancelErrorRead();
p.CancelOutputRead();
}
}
else
{
// Write the line to the log file.
LogToFile("StdErr", errLine.Data, true);
}
logMutex.ReleaseMutex();
}
}
private static void LogToFile(String logPrefix,
String logText, bool echoToConsole)
{
// Write the specified line to the log file stream.
StringBuilder logString = new StringBuilder();
if (!String.IsNullOrEmpty(logPrefix))
{
logString.AppendFormat("{0}> ", logPrefix);
}
if (!String.IsNullOrEmpty(logText))
{
logString.Append(logText);
}
if (buildLogStream != null)
{
buildLogStream.WriteLine("[{0}] {1}",
DateTime.Now.ToString(), logString.ToString());
buildLogStream.Flush();
}
if (echoToConsole)
{
Console.WriteLine(logString.ToString());
}
}
}
}
// Define static variables shared by class methods.
let mutable buildLogStream = Unchecked.defaultof<StreamWriter>
let logMutex = new Mutex()
let mutable maxLogLines = 25
let mutable currentLogLines = 0
let logToFile logPrefix logText echoToConsole =
// Write the specified line to the log file stream.
let logString = StringBuilder()
if String.IsNullOrEmpty logPrefix |> not then
logString.AppendFormat $"{logPrefix}> " |> ignore
if String.IsNullOrEmpty logPrefix |> not then
logString.AppendFormat $"{logPrefix}> " |> ignore
if String.IsNullOrEmpty logText |> not then
logString.Append logText |> ignore
if isNull buildLogStream |> not then
buildLogStream.WriteLine $"[{DateTime.Now}] {logString}"
buildLogStream.Flush()
if echoToConsole then
printfn $"{logString}"
let nMakeOutputDataHandler (sendingProcess: obj) (outLine: DataReceivedEventArgs) =
// Collect the output, displaying it to the screen and
// logging it to the output file. Cancel the read
// operation when the maximum line limit is reached.
if String.IsNullOrEmpty outLine.Data |> not then
logMutex.WaitOne() |> ignore
currentLogLines <- currentLogLines + 1
if currentLogLines > maxLogLines then
// Display the line to the console.
// Skip writing the line to the log file.
Console.WriteLine("StdOut: {0}", outLine.Data)
elif currentLogLines = maxLogLines then
logToFile "StdOut" "<Max build log limit reached!>" true
// Stop reading the output streams.
match sendingProcess with
| :? Process as p ->
p.CancelOutputRead()
p.CancelErrorRead()
| _ -> ()
else
// Write the line to the log file.
logToFile "StdOut" outLine.Data true
logMutex.ReleaseMutex()
let nMakeErrorDataHandler (sendingProcess: obj) (errLine: DataReceivedEventArgs) =
// Collect error output, displaying it to the screen and
// logging it to the output file. Cancel the error output
// read operation when the maximum line limit is reached.
if String.IsNullOrEmpty errLine.Data |> not then
logMutex.WaitOne() |> ignore
currentLogLines <- currentLogLines + 1
if currentLogLines > maxLogLines then
// Display the error line to the console.
// Skip writing the line to the log file.
printfn $"StdErr: {errLine.Data}"
elif currentLogLines = maxLogLines then
logToFile "StdErr" "<Max build log limit reached!>" true
// Stop reading the output streams
match sendingProcess with
| :? Process as p ->
p.CancelErrorRead()
p.CancelOutputRead()
| _ -> ()
else
// Write the line to the log file.
logToFile "StdErr" errLine.Data true
logMutex.ReleaseMutex()
let redirectNMakeCommandStreams () =
// Get the input nmake command-line arguments.
printfn "Enter the NMake command line arguments (@commandfile or /f makefile, etc):"
let nmakeArguments = stdin.ReadLine()
printfn "Enter max line limit for log file (default is 25):"
let inputText = Console.ReadLine()
if String.IsNullOrEmpty inputText |> not then
if Int32.TryParse(inputText, &maxLogLines) |> not then
maxLogLines <- 25
printfn $"Output beyond {maxLogLines} lines will be ignored."
// Initialize the process and its StartInfo properties.
let nmakeProcess = new Process()
nmakeProcess.StartInfo.FileName <- "NMake.exe"
// Build the nmake command argument list.
if String.IsNullOrEmpty nmakeArguments |> not then
nmakeProcess.StartInfo.Arguments <- nmakeArguments
// Set UseShellExecute to false for redirection.
nmakeProcess.StartInfo.UseShellExecute <- false
// Redirect the standard output of the nmake command.
// Read the stream asynchronously using an event handler.
nmakeProcess.StartInfo.RedirectStandardOutput <- true
nmakeProcess.OutputDataReceived.AddHandler(DataReceivedEventHandler nMakeOutputDataHandler)
// Redirect the error output of the nmake command.
nmakeProcess.StartInfo.RedirectStandardError <- true
nmakeProcess.ErrorDataReceived.AddHandler(DataReceivedEventHandler nMakeErrorDataHandler)
logMutex.WaitOne() |> ignore
currentLogLines <- 0
// Write a header to the log file.
let buildLogFile = "NmakeCmd.Txt"
try
buildLogStream <- new StreamWriter(buildLogFile, true)
with e ->
printfn $"Could not open output file {buildLogFile}"
printfn $"Exception = {e}"
printfn $"{e.Message}"
buildLogStream <- null
if isNull buildLogStream |> not then
printfn $"Nmake output logged to {buildLogFile}"
buildLogStream.WriteLine()
buildLogStream.WriteLine DateTime.Now
if String.IsNullOrEmpty nmakeArguments |> not then
buildLogStream.Write $"Command line = NMake {nmakeArguments}"
else
buildLogStream.Write "Command line = Nmake"
buildLogStream.WriteLine()
buildLogStream.Flush()
logMutex.ReleaseMutex()
// Start the process.
Console.WriteLine("\n\nStarting Nmake command...\n")
nmakeProcess.Start() |> ignore
// Start the asynchronous read of the error stream.
nmakeProcess.BeginErrorReadLine()
// Start the asynchronous read of the output stream.
nmakeProcess.BeginOutputReadLine()
// Let the nmake command run, collecting the output.
nmakeProcess.WaitForExit()
nmakeProcess.Close()
buildLogStream.Close()
logMutex.Dispose()
' Define the namespaces used by this sample.
Imports System.Text
Imports System.IO
Imports System.Diagnostics
Imports System.Threading
Imports System.ComponentModel
Class ProcessNMakeStreamRedirection
' Define static variables shared by class methods.
Private Shared buildLogStream As StreamWriter = Nothing
Private Shared logMutex As Mutex = New Mutex()
Private Shared maxLogLines As Integer = 25
Private Shared currentLogLines As Integer = 0
Public Shared Sub RedirectNMakeCommandStreams()
Dim nmakeArguments As String = Nothing
Dim nmakeProcess As Process
' Get the input nmake command-line arguments.
Console.WriteLine("Enter the NMake command line arguments" + _
" (@commandfile or /f makefile, etc):")
Dim inputText As String = Console.ReadLine()
If Not String.IsNullOrEmpty(inputText) Then
nmakeArguments = inputText
End If
Console.WriteLine("Enter max line limit for log file (default is 25):")
inputText = Console.ReadLine()
If Not String.IsNullOrEmpty(inputText) Then
If Not Int32.TryParse(inputText, maxLogLines) Then
maxLogLines = 25
End If
End If
Console.WriteLine("Output beyond {0} lines will be ignored.", _
maxLogLines)
' Initialize the process and its StartInfo properties.
nmakeProcess = New Process()
nmakeProcess.StartInfo.FileName = "NMake.exe"
' Build the nmake command argument list.
If Not String.IsNullOrEmpty(nmakeArguments) Then
nmakeProcess.StartInfo.Arguments = nmakeArguments
End If
' Set UseShellExecute to false for redirection.
nmakeProcess.StartInfo.UseShellExecute = False
' Redirect the standard output of the nmake command.
' Read the stream asynchronously using an event handler.
nmakeProcess.StartInfo.RedirectStandardOutput = True
AddHandler nmakeProcess.OutputDataReceived, _
AddressOf NMakeOutputDataHandler
' Redirect the error output of the nmake command.
nmakeProcess.StartInfo.RedirectStandardError = True
AddHandler nmakeProcess.ErrorDataReceived, _
AddressOf NMakeErrorDataHandler
logMutex.WaitOne()
currentLogLines = 0
' Write a header to the log file.
Const buildLogFile As String = "NmakeCmd.Txt"
Try
buildLogStream = new StreamWriter(buildLogFile, true)
Catch e As Exception
Console.WriteLine("Could not open output file {0}", buildLogFile)
Console.WriteLine("Exception = {0}", e.ToString())
Console.WriteLine(e.Message)
buildLogStream = Nothing
End Try
If Not buildLogStream Is Nothing Then
Console.WriteLine("Nmake output logged to {0}", _
buildLogFile)
buildLogStream.WriteLine()
buildLogStream.WriteLine(DateTime.Now.ToString())
If Not String.IsNullOrEmpty(nmakeArguments) Then
buildLogStream.Write("Command line = NMake {0}", _
nmakeArguments)
Else
buildLogStream.Write("Command line = Nmake")
End If
buildLogStream.WriteLine()
buildLogStream.Flush()
logMutex.ReleaseMutex()
' Start the process.
Console.WriteLine()
Console.WriteLine("\nStarting Nmake command...")
Console.WriteLine()
nmakeProcess.Start()
' Start the asynchronous read of the error stream.
nmakeProcess.BeginErrorReadLine()
' Start the asynchronous read of the output stream.
nmakeProcess.BeginOutputReadLine()
' Let the nmake command run, collecting the output.
nmakeProcess.WaitForExit()
nmakeProcess.Close()
buildLogStream.Close()
logMutex.Dispose()
End If
End Sub
Private Shared Sub NMakeOutputDataHandler(sendingProcess As Object, _
outLine As DataReceivedEventArgs)
' Collect the output, displaying it to the screen and
' logging it to the output file. Cancel the read
' operation when the maximum line limit is reached.
If Not String.IsNullOrEmpty(outLine.Data) Then
logMutex.WaitOne()
currentLogLines = currentLogLines + 1
If currentLogLines > maxLogLines Then
' Display the line to the console.
' Skip writing the line to the log file.
Console.WriteLine("StdOut: {0}", outLine.Data)
Else If currentLogLines = maxLogLines Then
LogToFile("StdOut", "<Max build log limit reached!>", _
true)
' Stop reading the output streams.
Dim p As Process = sendingProcess
If Not (p Is Nothing) Then
p.CancelOutputRead()
p.CancelErrorRead()
End If
Else
' Write the line to the log file.
LogToFile("StdOut", outLine.Data, true)
End If
logMutex.ReleaseMutex()
End If
End Sub
Private Shared Sub NMakeErrorDataHandler(sendingProcess As Object, _
errLine As DataReceivedEventArgs)
' Collect the error output, displaying it to the screen and
' logging it to the output file. Cancel the error output
' read operation when the maximum line limit is reached.
If Not String.IsNullOrEmpty(errLine.Data) Then
logMutex.WaitOne()
currentLogLines = currentLogLines + 1
If currentLogLines > maxLogLines Then
' Display the line to the console.
' Skip writing the line to the log file.
Console.WriteLine("StdErr: {0}", errLine.Data)
Else If currentLogLines = maxLogLines Then
LogToFile("StdErr", "<Max build log limit reached!>", _
true)
' Stop reading the output streams.
Dim p As Process = sendingProcess
If Not (p Is Nothing) Then
p.CancelOutputRead()
p.CancelErrorRead()
End If
Else
' Write the line to the log file.
LogToFile("StdErr", errLine.Data, true)
End If
logMutex.ReleaseMutex()
End If
End Sub
Private Shared Sub LogToFile(logPrefix As String, _
logText As String, _
echoToConsole As String)
' Write the specified line to the log file stream.
Dim logString As StringBuilder = New StringBuilder()
If Not String.IsNullOrEmpty(logPrefix) Then
logString.AppendFormat("{0}> ", logPrefix)
End If
If Not String.IsNullOrEmpty(logText) Then
logString.Append(logText)
End If
If Not buildLogStream Is Nothing Then
buildLogStream.WriteLine("[{0}] {1}", _
DateTime.Now.ToString(), logString.ToString())
buildLogStream.Flush()
End If
If echoToConsole Then
Console.WriteLine(logString.ToString())
End If
End Sub
End Class
Remarks
BeginErrorReadLine starts an asynchronous read operation on the StandardError stream. CancelErrorRead ends the asynchronous read operation.
After canceling, you can resume the asynchronous read operation by calling BeginErrorReadLine again.
When you call CancelErrorRead, all in-progress read operations for StandardError are completed and then the event handler is disabled. All further redirected output to StandardError will be lost. If you re-enable the event handler with a call to BeginErrorReadLine, asynchronous read operations resume. If you want to change the event handler before resuming asynchronous read operations, you must remove the existing event handler before adding the new event handler:
// At this point the DataReceivedEventHandler(ErrorHandler1)
// has executed a CancelErrorRead.
// Remove the prior event handler.
process.ErrorDataReceived -=
new DataReceivedEventHandler(ErrorHandler1);
// Register a new event handler.
process.ErrorDataReceived +=
new DataReceivedEventHandler(ErrorHandler2);
// Call the corresponding BeginErrorReadLine.
process.BeginErrorReadLine();
Note
You cannot mix asynchronous and synchronous read operations on the redirected StandardError stream. Once the redirected stream of a Process is opened in either asynchronous or synchronous mode, all further read operations on that stream must be in the same mode. If you cancel an asynchronous read operation on StandardError and then need to read from the stream again, you must use BeginErrorReadLine to resume asynchronous read operations. Do not follow CancelErrorRead with a call to the synchronous read methods of StandardError such as Read, ReadLine, or ReadToEnd.
Applies to
See also
Samarbeta med oss på GitHub
Källan för det här innehållet finns på GitHub, där du även kan skapa och granska ärenden och pull-begäranden. Se vår deltagarguide för mer information.
