Process.StandardError Eigenschaft

Definition

Ruft einen Stream ab, mit dem die Fehlerausgabe der Anwendung gelesen wird.Gets a stream used to read the error output of the application.

public:
 property System::IO::StreamReader ^ StandardError { System::IO::StreamReader ^ get(); };
public System.IO.StreamReader StandardError { get; }
[System.ComponentModel.Browsable(false)]
public System.IO.StreamReader StandardError { get; }
member this.StandardError : System.IO.StreamReader
[<System.ComponentModel.Browsable(false)>]
member this.StandardError : System.IO.StreamReader
Public ReadOnly Property StandardError As StreamReader

Eigenschaftswert

StreamReader

Ein StreamReader zum Lesen des Standardfehlerstreams der Anwendung.A StreamReader that can be used to read the standard error stream of the application.

Attribute

Ausnahmen

Der StandardError-Stream wurde nicht für die Umleitung definiert. Stellen Sie sicher, dass RedirectStandardError auf true und UseShellExecute auf false festgelegt ist.The StandardError stream has not been defined for redirection; ensure RedirectStandardError is set to true and UseShellExecute is set to false.

- oder --or- Der StandardError-Stream wurde für asynchrone Lesevorgänge mit BeginErrorReadLine() geöffnet.The StandardError stream has been opened for asynchronous read operations with BeginErrorReadLine().

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 normalerweise in der Konsole angezeigt.When a Process writes text to its standard error stream, that text is normally 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

Um zu verwenden StandardError , müssen Sie ProcessStartInfo.UseShellExecute auf festlegen false , und Sie müssen ProcessStartInfo.RedirectStandardError auf festlegen true .To use StandardError, you must set ProcessStartInfo.UseShellExecute to false, and you must set ProcessStartInfo.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.

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 zu Deadlock-Bedingungen führen.These dependencies can result in 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 on 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 on 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 aufeinander warten, um einen Vorgang abzuschließen.The deadlock condition results when the caller and child process wait on each other to complete an operation, and neither can proceed. 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. Im folgenden Beispiel wird ein Lesevorgang für beide Streams durchführt.The following 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.

Hinweis

Asynchrone und synchrone Lesevorgänge können nicht in einem umgeleiteten Stream gemischt werden.You cannot mix asynchronous and synchronous read operations on a redirected stream. Sobald der umgeleitete Stream eines Process im asynchronen oder im synchronen Modus geöffnet ist, müssen sich alle weiteren Lesevorgänge in diesem Stream im gleichen Modus befinden.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. Folgen Sie z BeginErrorReadLine . b. nicht mit einem aufrufen ReadLine von für den StandardError Stream oder umgekehrt.For example, do not follow BeginErrorReadLine with a call to ReadLine on the StandardError stream, or vice versa. Sie können jedoch zwei verschiedene Streams in verschiedenen Modi lesen.However, you can read two different streams in different modes. Sie können z. b. aufzurufen BeginOutputReadLine und dann ReadLine für den Stream aufzurufen StandardError .For example, you can call BeginOutputReadLine and then call ReadLine for the StandardError stream.

Gilt für:

Siehe auch