Process.StandardError Eigenschaft

Definition

Namespace:

System.Diagnostics

Assembly:

System.Diagnostics.Process.dll

Quelle:

Process.cs

Ruft einen Stream ab, mit dem die Fehlerausgabe der Anwendung gelesen wird.

public:
 property System::IO::StreamReader ^ StandardError { System::IO::StreamReader ^ get(); };

public System.IO.StreamReader StandardError { get; }

member this.StandardError : System.IO.StreamReader

Public ReadOnly Property StandardError As StreamReader

Eigenschaftswert

StreamReader

Ein StreamReader zum Lesen des Standardfehlerstreams der Anwendung.

Ausnahmen

InvalidOperationException

Der StandardError-Stream wurde nicht für die Umleitung definiert. Stellen Sie sicher, dass RedirectStandardError auf true und UseShellExecute auf false festgelegt ist.

- oder -

Der StandardError-Stream wurde für asynchrone Lesevorgänge mit BeginErrorReadLine() geöffnet.

Beispiele

Im folgenden Beispiel wird der net use Befehl zusammen mit einem vom Benutzer bereitgestellten Argument verwendet, um eine Netzwerkressource zuzuordnen. Anschließend liest er den Standardfehlerstrom des Net-Befehls und schreibt ihn in die Konsole.

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 Standardfehlerstrom schreibt, wird dieser Text normalerweise auf der Konsole angezeigt. Durch Umleitung des Datenstroms StandardError können Sie die Fehlerausgabe eines Prozesses bearbeiten oder unterdrücken. Beispielsweise können Sie den Text filtern, anders formatieren oder die Ausgabe sowohl in die Konsole als auch in eine festgelegte Protokolldatei schreiben.

Hinweis

Um zu verwendenStandardError, müssen Sie auf falsefestlegenProcessStartInfo.UseShellExecute, und Sie müssen auf truefestlegenProcessStartInfo.RedirectStandardError. Andernfalls löst das Lesen aus dem StandardError Stream eine Ausnahme aus.

Der umgeleitete StandardError Stream kann synchron oder asynchron gelesen werden. Methoden wie Read, ReadLineund ReadToEnd führen synchrone Lesevorgänge für den Fehlerausgabestream des Prozesses aus. Diese synchronen Lesevorgänge werden erst abgeschlossen, wenn die zugeordneten Process Schreibvorgänge in den StandardError Stream oder den Stream geschlossen werden.

Im Gegensatz dazu BeginErrorReadLine werden asynchrone Lesevorgänge für den StandardError Stream gestartet. Diese Methode aktiviert einen angegebenen Ereignishandler für die Streamausgabe und kehrt sofort an den Aufrufer zurück, der andere Arbeiten ausführen kann, während die Streamausgabe an den Ereignishandler weitergeleitet wird.

Synchrone Lesevorgänge führen eine Abhängigkeit zwischen dem Aufrufer, der aus dem StandardError Stream liest, und dem untergeordneten Prozess, der in diesen Stream schreibt. Diese Abhängigkeiten können zu Deadlockbedingungen führen. Wenn der Aufrufer aus dem umgeleiteten Stream eines untergeordneten Prozesses liest, ist er vom untergeordneten Prozess abhängig. Der Aufrufer wartet auf den Lesevorgang, bis das untergeordnete Element in den Stream schreibt oder den Stream schließt. Wenn der untergeordnete Prozess genügend Daten schreibt, um den umgeleiteten Stream zu füllen, ist er vom übergeordneten Prozess abhängig. Der untergeordnete Prozess wartet beim nächsten Schreibvorgang, bis das übergeordnete Element aus dem vollständigen Stream liest oder den Stream schließt. Die Deadlockbedingung ergibt sich, wenn aufrufer und untergeordneter Prozess aufeinander warten, um einen Vorgang abzuschließen, und beide können nicht fortgesetzt werden. Sie können Deadlocks vermeiden, indem Sie Abhängigkeiten zwischen dem Aufrufer und dem untergeordneten Prozess auswerten.

In den letzten beiden Beispielen in diesem Abschnitt wird die Start -Methode verwendet, um eine ausführbare Datei namens Write500Lines.exezu starten. Das folgende Beispiel enthält den Quellcode.

using System;
using System.IO;

public class Example3
{
   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.

Das folgende Beispiel zeigt, wie Sie aus einem umgeleiteten Fehlerdatenstrom lesen und warten, bis der untergeordnete Prozess beendet wird. Es vermeidet eine Deadlockbedingung, indem vor p.WaitForExitaufgerufen p.StandardError.ReadToEnd wird. Eine Deadlockbedingung kann auftreten, wenn der übergeordnete Prozess vor p.StandardError.ReadToEnd aufruft p.WaitForExit und der untergeordnete Prozess genügend Text schreibt, um den umgeleiteten Stream auszufüllen. Der übergeordnete Prozess wartet unbegrenzt, bis der untergeordnete Prozess beendet wird. Der untergeordnete Prozess wartet unbegrenzt, bis das übergeordnete Element aus dem vollständigen StandardError Stream lesen kann.

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 Standardfehlerdatenströmen lesen. Im folgenden Beispiel wird ein Lesevorgang für beide Streams ausgeführt. Es vermeidet die Deadlockbedingung, indem asynchrone Lesevorgänge für den StandardError Stream ausgeführt werden. Eine Deadlockbedingung ergibt sich, wenn der übergeordnete Prozess gefolgt von p.StandardError.ReadToEnd aufruft p.StandardOutput.ReadToEnd und der untergeordnete Prozess genügend Text schreibt, um seinen Fehlerdatenstrom auszufüllen. Der übergeordnete Prozess wartet unbegrenzt, bis der untergeordnete Prozess seinen StandardOutput Stream schließt. Der untergeordnete Prozess wartet unbegrenzt, bis das übergeordnete Element aus dem vollständigen StandardError Stream lesen kann.

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. Alternativ können Sie die Deadlockbedingung vermeiden, indem Sie zwei Threads erstellen und die Ausgabe jedes Datenstroms in einem separaten Thread lesen.

Hinweis

Sie können keine asynchronen und synchronen Lesevorgänge für einen umgeleiteten Stream kombinieren. Sobald der umgeleitete Stream eines im Process asynchronen oder synchronen Modus geöffnet wird, müssen sich alle weiteren Lesevorgänge für diesen Stream im gleichen Modus befinden. Folgen Sie BeginErrorReadLine beispielsweise nicht mit einem Aufruf von ReadLine im StandardError Stream oder umgekehrt. Sie können jedoch zwei verschiedene Streams in verschiedenen Modi lesen. Beispielsweise können Sie den StandardError Stream aufrufen BeginOutputReadLine und dann aufrufenReadLine.

Weitere Informationen

• StandardInput
• StandardOutput
• RedirectStandardError