ProcessStartInfo.RedirectStandardError Eigenschaft

Definition

Ruft einen Wert ab, der angibt, ob die Fehlerausgabe einer Anwendung in den StandardError -Datenstrom geschrieben wird, oder legt diesen fest.Gets or sets a value that indicates whether the error output of an application is written to the StandardError stream.

public:
 property bool RedirectStandardError { bool get(); void set(bool value); };
public bool RedirectStandardError { get; set; }
member this.RedirectStandardError : bool with get, set
Public Property RedirectStandardError As Boolean

Eigenschaftswert

Boolean

true , wenn die Fehlerausgabe in StandardErrorgeschrieben werden soll; andernfalls false.true if error output should be written to StandardError; otherwise, false. Der Standardwert ist false.The default is false.

Beispiele

Im folgenden Beispiel wird der net use -Befehl in Verbindung mit einem vom Benutzer bereitgestellten Argument verwendet, um eine Netzwerkressource zuzuordnen.The following example uses the net use command together with a user-supplied argument to map a network resource. Anschließend wird der Standardfehlerstream des NET-Befehls gelesen und in die Konsole geschrieben.It then reads the standard error stream of the net command and writes it to console.

Process^ myProcess = gcnew Process;
ProcessStartInfo^ myProcessStartInfo = gcnew ProcessStartInfo( "net ",String::Concat( "use ", args[ 0 ] ) );

myProcessStartInfo->UseShellExecute = false;
myProcessStartInfo->RedirectStandardError = true;
myProcess->StartInfo = myProcessStartInfo;
myProcess->Start();

StreamReader^ myStreamReader = myProcess->StandardError;
// Read the standard error of net.exe and write it on to console.
Console::WriteLine( myStreamReader->ReadLine() );
myProcess->Close();
using (Process myProcess = new Process())
{
    ProcessStartInfo myProcessStartInfo = new ProcessStartInfo("net ", "use " + args[0]);

    myProcessStartInfo.UseShellExecute = false;
    myProcessStartInfo.RedirectStandardError = true;
    myProcess.StartInfo = myProcessStartInfo;
    myProcess.Start();

    StreamReader myStreamReader = myProcess.StandardError;
    // Read the standard error of net.exe and write it on to console.
    Console.WriteLine(myStreamReader.ReadLine());
}
Using myProcess As New Process()
    Dim myProcessStartInfo As New ProcessStartInfo("net ", "use " + args(0))

    myProcessStartInfo.UseShellExecute = False
    myProcessStartInfo.RedirectStandardError = True
    myProcess.StartInfo = myProcessStartInfo
    myProcess.Start()

    Dim myStreamReader As StreamReader = myProcess.StandardError
    ' Read the standard error of net.exe and write it on to console.
    Console.WriteLine(myStreamReader.ReadLine())
End Using

Hinweise

Wenn ein Process Text in seinen Standardfehlerstream schreibt, wird dieser Text in der Regel in der Konsole angezeigt.When a Process writes text to its standard error stream, that text is typically displayed on the console. Wenn Sie den Stream umleiten StandardError , können Sie die Fehlerausgabe eines Prozesses ändern oder unterdrücken.By redirecting the StandardError stream, you can manipulate or suppress the error output of a process. Beispielsweise können Sie den Text filtern, ihn anders formatieren oder die Ausgabe in die Konsole und eine bestimmte Protokolldatei schreiben.For example, you can filter the text, format it differently, or write the output to both the console and a designated log file.

Hinweis

Sie müssen UseShellExecute auf festlegen, false Wenn Sie auf festlegen RedirectStandardError möchten true .You must set UseShellExecute to false if you want to set RedirectStandardError to true. Andernfalls löst das Lesen aus dem StandardError Stream eine Ausnahme aus.Otherwise, reading from the StandardError stream throws an exception.

Der umgeleitete StandardError Stream kann synchron oder asynchron gelesen werden.The redirected StandardError stream can be read synchronously or asynchronously. Methoden wie Read ReadLine und ReadToEnd führen synchrone Lesevorgänge im Fehlerausgabestream des Prozesses aus.Methods such as Read, ReadLine and ReadToEnd perform synchronous read operations on the error output stream of the process. Diese synchronen Lesevorgänge werden erst abgeschlossen, wenn die zugeordnete Process in Ihren StandardError Stream schreibt, oder der Stream wird geschlossen.These synchronous read operations do not complete until the associated Process writes to its StandardError stream, or closes the stream.

Im Gegensatz dazu BeginErrorReadLine startet asynchrone Lesevorgänge im StandardError Stream.In contrast, BeginErrorReadLine starts asynchronous read operations on the StandardError stream. Diese Methode aktiviert einen festgelegten Ereignishandler für die Datenstrom Ausgabe und kehrt sofort an den Aufrufer zurück, der andere Aufgaben ausführen kann, während die Datenstrom Ausgabe an den Ereignishandler weitergeleitet wird.This method enables a designated event handler for the stream output and immediately returns to the caller, which can perform other work while the stream output is directed to the event handler.

Hinweis

Die Anwendung, die die asynchrone Ausgabe verarbeitet, sollte die-Methode aufzurufen Process.WaitForExit , um sicherzustellen, dass der Ausgabepuffer geleert wurde.The application that is processing the asynchronous output should call the Process.WaitForExit method to ensure that the output buffer has been flushed.

Synchrone Lesevorgänge stellen eine Abhängigkeit zwischen dem aus dem StandardError Stream gelesenen Aufrufer und dem untergeordneten Prozess vor, der in diesen Stream schreibtSynchronous read operations introduce a dependency between the caller reading from the StandardError stream and the child process writing to that stream. Diese Abhängigkeiten können Deadlock-Bedingungen verursachen.These dependencies can cause deadlock conditions. Wenn der Aufrufer aus dem umgeleiteten Stream eines untergeordneten Prozesses liest, ist er vom untergeordneten Element abhängig.When the caller reads from the redirected stream of a child process, it is dependent on the child. Der Aufrufer wartet auf den Lesevorgang, bis das untergeordnete Objekt in den Stream schreibt oder den Stream schließt.The caller waits for the read operation until the child writes to the stream or closes the stream. Wenn der untergeordnete Prozess genügend Daten schreibt, um den umgeleiteten Stream auszufüllen, ist er vom übergeordneten Prozess abhängig.When the child process writes enough data to fill its redirected stream, it is dependent on the parent. Der untergeordnete Prozess wartet auf den nächsten Schreibvorgang, bis das übergeordnete Element aus dem vollständigen Stream liest oder den Stream schließt.The child process waits for the next write operation until the parent reads from the full stream or closes the stream. Die Deadlockbedingung ergibt sich, wenn der Aufrufer und der untergeordnete Prozess auf den Abschluss eines Vorgangs warten und keines der beiden Vorgänge fortgesetzt werden kann.The deadlock condition results when the caller and child process wait for each other to complete an operation, and neither can continue. Sie können Deadlocks vermeiden, indem Sie Abhängigkeiten zwischen dem Aufrufer und dem untergeordneten Prozess auswerten.You can avoid deadlocks by evaluating dependencies between the caller and child process.

In den letzten beiden Beispielen in diesem Abschnitt wird die- Start Methode verwendet, um eine ausführbare Datei namens Write500Lines.exe zu starten.The last two examples in this section use the Start method to launch an executable named Write500Lines.exe. Das folgende Beispiel enthält den Quellcode.The following example contains its source code.

using System;
using System.IO;

public class Example
{
   public static void Main()
   {
      for (int ctr = 0; ctr < 500; ctr++)
         Console.WriteLine($"Line {ctr + 1} of 500 written: {ctr + 1/500.0:P2}");

      Console.Error.WriteLine("\nSuccessfully wrote 500 lines.\n");
   }
}
// The example displays the following output:
//      The last 50 characters in the output stream are:
//      ' 49,800.20%
//      Line 500 of 500 written: 49,900.20%
//'
//
//      Error stream: Successfully wrote 500 lines.
Imports System.IO

Public Module Example
   Public Sub Main()
      For ctr As Integer = 0 To 499
         Console.WriteLine($"Line {ctr + 1} of 500 written: {ctr + 1/500.0:P2}")
      Next

      Console.Error.WriteLine($"{vbCrLf}Successfully wrote 500 lines.{vbCrLf}")
   End Sub
End Module
' The example displays the following output:
'      The last 50 characters in the output stream are:
'      ' 49,800.20%
'      Line 500 of 500 written: 49,900.20%
'
'
'      Error stream: Successfully wrote 500 lines.

Im folgenden Beispiel wird gezeigt, wie Sie aus einem umgeleiteten Fehler Datenstrom lesen und warten, bis der untergeordnete Prozess beendet wird.The following example shows how to read from a redirected error stream and wait for the child process to exit. Durch den Aufruf von vor wird eine Deadlockbedingung vermieden p.StandardError.ReadToEnd p.WaitForExit .It avoids a deadlock condition by calling p.StandardError.ReadToEnd before p.WaitForExit. Ein Deadlockzustand kann auftreten, wenn der übergeordnete Prozess p.WaitForExit vor aufruft p.StandardError.ReadToEnd und der untergeordnete Prozess genug Text schreibt, um den umgeleiteten Stream auszufüllen.A deadlock condition can result if the parent process calls p.WaitForExit before p.StandardError.ReadToEnd and the child process writes enough text to fill the redirected stream. Der übergeordnete Prozess wartet unbegrenzt, bis der untergeordnete Prozess beendet wird.The parent process would wait indefinitely for the child process to exit. Der untergeordnete Prozess wartet unbegrenzt, bis das übergeordnete Element aus dem vollständigen Stream gelesen wird StandardError .The child process would wait indefinitely for the parent to read from the full StandardError stream.

using System;
using System.Diagnostics;

public class Example
{
   public static void Main()
   {
      var p = new Process();  
      p.StartInfo.UseShellExecute = false;  
      p.StartInfo.RedirectStandardError = true;  
      p.StartInfo.FileName = "Write500Lines.exe";  
      p.Start();  

      // To avoid deadlocks, always read the output stream first and then wait.  
      string output = p.StandardError.ReadToEnd();  
      p.WaitForExit();

      Console.WriteLine($"\nError stream: {output}");
   }
}
// The end of the output produced by the example includes the following:
//      Error stream:
//      Successfully wrote 500 lines.
Imports System.Diagnostics

Public Module Example
    Public Sub Main()
        Dim p As New Process()
        p.StartInfo.UseShellExecute = False  
        p.StartInfo.RedirectStandardError = True  
        p.StartInfo.FileName = "Write500Lines.exe"  
        p.Start() 

        ' To avoid deadlocks, always read the output stream first and then wait.  
        Dim output As String = p.StandardError.ReadToEnd()  
        p.WaitForExit()

        Console.WriteLine($"{vbCrLf}Error stream: {output}")
    End Sub
End Module
' The end of the output produced by the example includes the following:
'      Error stream:
'      Successfully wrote 500 lines.

Es gibt ein ähnliches Problem, wenn Sie den gesamten Text sowohl aus der Standardausgabe als auch aus den Standardfehlerstreams lesen.There is a similar issue when you read all text from both the standard output and standard error streams. Der folgende c#-Code führt z. b. einen Lesevorgang für beide Streams aus.The following C# code, for example, performs a read operation on both streams. Die Deadlockbedingung wird vermieden, indem asynchrone Lesevorgänge im Stream durchgeführt werden StandardError .It avoids the deadlock condition by performing asynchronous read operations on the StandardError stream. Eine Deadlockbedingung ergibt sich, wenn der p.StandardOutput.ReadToEnd übergeordnete Prozess gefolgt von aufruft p.StandardError.ReadToEnd und der untergeordnete Prozess genug Text schreibt, um den Fehler Datenstrom auszufüllen.A deadlock condition results if the parent process calls p.StandardOutput.ReadToEnd followed by p.StandardError.ReadToEnd and the child process writes enough text to fill its error stream. Der übergeordnete Prozess wartet unbegrenzt, bis der untergeordnete Prozess seinen StandardOutput Stream schließt.The parent process would wait indefinitely for the child process to close its StandardOutput stream. Der untergeordnete Prozess wartet unbegrenzt, bis das übergeordnete Element aus dem vollständigen Stream gelesen wird StandardError .The child process would wait indefinitely for the parent to read from the full StandardError stream.

using System;
using System.Diagnostics;

public class Example
{
   public static void Main()
   {
      var p = new Process();  
      p.StartInfo.UseShellExecute = false;  
      p.StartInfo.RedirectStandardOutput = true;  
      string eOut = null;
      p.StartInfo.RedirectStandardError = true;
      p.ErrorDataReceived += new DataReceivedEventHandler((sender, e) => 
                                 { eOut += e.Data; });
      p.StartInfo.FileName = "Write500Lines.exe";  
      p.Start();  

      // To avoid deadlocks, use an asynchronous read operation on at least one of the streams.  
      p.BeginErrorReadLine();
      string output = p.StandardOutput.ReadToEnd();  
      p.WaitForExit();

      Console.WriteLine($"The last 50 characters in the output stream are:\n'{output.Substring(output.Length - 50)}'");
      Console.WriteLine($"\nError stream: {eOut}");
   }
}
// The example displays the following output:
//      The last 50 characters in the output stream are:
//      ' 49,800.20%
//      Line 500 of 500 written: 49,900.20%
//      '
//
//      Error stream: Successfully wrote 500 lines.
Imports System.Diagnostics

Public Module Example
   Public Sub Main()
      Dim p As New Process()  
      p.StartInfo.UseShellExecute = False  
      p.StartInfo.RedirectStandardOutput = True  
      Dim eOut As String = Nothing
      p.StartInfo.RedirectStandardError = True
      AddHandler p.ErrorDataReceived, Sub(sender, e) eOut += e.Data 
      p.StartInfo.FileName = "Write500Lines.exe"  
      p.Start()  

      ' To avoid deadlocks, use an asynchronous read operation on at least one of the streams.  
      p.BeginErrorReadLine()
      Dim output As String = p.StandardOutput.ReadToEnd()  
      p.WaitForExit()

      Console.WriteLine($"The last 50 characters in the output stream are:{vbCrLf}'{output.Substring(output.Length - 50)}'")
      Console.WriteLine($"{vbCrLf}Error stream: {eOut}")
   End Sub
End Module
' The example displays the following output:
'      The last 50 characters in the output stream are:
'      ' 49,800.20%
'      Line 500 of 500 written: 49,900.20%
'      '
'
'      Error stream: Successfully wrote 500 lines.

Sie können asynchrone Lesevorgänge verwenden, um diese Abhängigkeiten und ihr Deadlockpotenzial zu vermeiden.You can use asynchronous read operations to avoid these dependencies and their deadlock potential. Alternativ können Sie die Deadlockbedingung vermeiden, indem Sie zwei Threads erstellen und die Ausgabe der einzelnen Datenströme in einem separaten Thread lesen.Alternately, you can avoid the deadlock condition by creating two threads and reading the output of each stream on a separate thread.

Gilt für:

Siehe auch