Process.StandardError Eigenschaft

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

Eine StreamReader , die verwendet werden kann, um den Standardfehlerdatenstrom der Anwendung zu lesen.

Attribute

BrowsableAttribute

Ausnahmen

Beispiele

Im folgenden Beispiel wird der net use Befehl zusammen mit einem vom Benutzer bereitgestellten Argument verwendet, um eine Netzwerkressource zuzuordnen. Anschließend wird der Standardfehlerdatenstrom des Net-Befehls gelesen und in die Konsole geschrieben.

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());
}

use myProcess = new Process()
let myProcessStartInfo = ProcessStartInfo("net ", $"use {args[0]}")

myProcessStartInfo.UseShellExecute <- false
myProcessStartInfo.RedirectStandardError <- true
myProcess.StartInfo <- myProcessStartInfo
myProcess.Start() |> ignore

let myStreamReader = myProcess.StandardError
// Read the standard error of net.exe and write it on to console.
printfn $"{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 den Standardfehlerstrom schreibt, wird dieser Text normalerweise auf der Konsole angezeigt. Durch Umleitung des StandardError Datenstroms können Sie die Fehlerausgabe eines Prozesses bearbeiten oder unterdrücken. Sie können z. B. den Text filtern, anders formatieren oder die Ausgabe sowohl in die Konsole als auch in eine festgelegte Protokolldatei schreiben.

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

Startet dagegen BeginErrorReadLine asynchrone Lesevorgänge im StandardError Datenstrom. Mit dieser Methode wird ein festgelegter Ereignishandler für die Datenstromausgabe aktiviert und sofort an den Aufrufer zurückgegeben, der andere Aufgaben ausführen kann, während die Streamausgabe an den Ereignishandler weitergeleitet wird.

Synchrone Lesevorgänge führen zu einer Abhängigkeit zwischen dem Lesevorgang des Aufrufers aus dem StandardError Datenstrom und dem untergeordneten Prozess, der in diesen Datenstrom geschrieben wird. Diese Abhängigkeiten können zu Deadlockbedingungen führen. Wenn der Aufrufer aus dem umgeleiteten Datenstrom eines untergeordneten Prozesses liest, ist er vom untergeordneten Element abhängig. Der Aufrufer wartet auf den Lesevorgang, bis das untergeordnete Element in den Datenstrom schreibt oder den Datenstrom schließt. Wenn der untergeordnete Prozess genügend Daten schreibt, um den umgeleiteten Datenstrom auszufüllen, hängt er vom übergeordneten Element ab. Der untergeordnete Prozess wartet auf den nächsten Schreibvorgang, bis das übergeordnete Element aus dem vollständigen Datenstrom liest oder den Datenstrom schließt. Die Deadlock-Bedingung ergibt sich, wenn der Aufrufer und der untergeordnete 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 zum Starten einer ausführbaren Datei mit dem Namen Write500Lines.exeverwendet. Das folgende Beispiel enthält den Quellcode.

using System;

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:
//      Line 1 of 500 written: 0,20%
//      Line 2 of 500 written: 0,40%
//      Line 3 of 500 written: 0,60%
//      ...
//      Line 498 of 500 written: 99,60%
//      Line 499 of 500 written: 99,80%
//      Line 500 of 500 written: 100,00%
//
//      Successfully wrote 500 lines.

module Write500Lines

for i in 1. .. 500. do
    printfn $"Line {i} of 500 written: {i/500.:P2}";

eprintfn "Successfully wrote 500 lines.";
// The example displays the following output:
//      Line 1 of 500 written: 0,20%
//      Line 2 of 500 written: 0,40%
//      Line 3 of 500 written: 0,60%
//      ...
//      Line 498 of 500 written: 99,60%
//      Line 499 of 500 written: 99,80%
//      Line 500 of 500 written: 100,00%
//      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:
'      Line 1 of 500 written 0,20%
'      Line 2 of 500 written: 0,40%
'      Line 3 of 500 written: 0,60%
'      ...
'      Line 498 of 500 written: 99,60%
'      Line 499 of 500 written: 99,80%
'      Line 500 of 500 written: 100,00%
'
'      Successfully wrote 500 lines.

Das folgende Beispiel zeigt, wie Sie aus einem umgeleiteten Fehlerdatenstrom lesen und warten, bis der untergeordnete Prozess beendet wird. Dadurch wird eine Deadlock-Bedingung vermieden, indem vor p.StandardError.ReadToEnddem Aufruf aufgerufen wirdp.WaitForExit. Eine Deadlock-Bedingung kann dazu führen, dass der übergeordnete Prozess p.WaitForExit vor p.StandardError.ReadToEnd und der untergeordnete Prozess genügend Text schreibt, um den umgeleiteten Datenstrom auszufüllen. Der übergeordnete Prozess würde auf unbestimmte Zeit warten, bis der untergeordnete Prozess beendet wurde. Der untergeordnete Prozess würde auf unbestimmte Zeit warten, bis das übergeordnete Element aus dem vollständigen StandardError Datenstrom gelesen wurde.

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.

module STDErrorSync

open System.Diagnostics

let p = new Process()
p.StartInfo.UseShellExecute <- false
p.StartInfo.RedirectStandardError <- true
p.StartInfo.FileName <- "Write500Lines.exe"
p.Start() |> ignore

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

printfn $"\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 aus den Standardausgabe- und Standardfehlerdatenströmen lesen. Im folgenden Beispiel wird ein Lesevorgang für beide Datenströme ausgeführt. Die Deadlock-Bedingung wird vermieden, indem asynchrone Lesevorgänge für den StandardError Datenstrom ausgeführt werden. Eine Deadlock-Bedingung führt dazu, dass der übergeordnete Prozess gefolgt wird p.StandardOutput.ReadToEndp.StandardError.ReadToEnd und der untergeordnete Prozess genügend Text schreibt, um den Fehlerdatenstrom auszufüllen. Der übergeordnete Prozess würde auf unbestimmte Zeit warten, bis der untergeordnete Prozess seinen StandardOutput Datenstrom schließt. Der untergeordnete Prozess würde auf unbestimmte Zeit warten, bis das übergeordnete Element aus dem vollständigen StandardError Datenstrom gelesen wurde.

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:
//      'ritten: 99,80%
//      Line 500 of 500 written: 100,00%
//      '
//
//      Error stream: Successfully wrote 500 lines.

module STDOutputAsync

open System.Diagnostics

let p = new Process()
p.StartInfo.UseShellExecute <- false
p.StartInfo.RedirectStandardOutput <- true
let mutable eOut = ""
p.StartInfo.RedirectStandardError <- true
p.ErrorDataReceived.AddHandler(DataReceivedEventHandler(fun sender e -> eOut <- eOut + e.Data))

p.StartInfo.FileName <- "Write500Lines.exe"
p.Start() |> ignore

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

printfn $"The last 50 characters in the output stream are:\n'{output.Substring(output.Length - 50)}'"
printfn $"\nError stream: {eOut}"
// The example displays the following output:
//      The last 50 characters in the output stream are:
//      'ritten: 99,80%
//      Line 500 of 500 written: 100,00%
//      '
//
//      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:
'      'ritten: 99,80%
'      Line 500 of 500 written: 100,00%
'      '
'
'      Error stream: Successfully wrote 500 lines.

Sie können asynchrone Lesevorgänge verwenden, um diese Abhängigkeiten und deren Deadlockpotenzial zu vermeiden. Alternativ können Sie die Deadlock-Bedingung vermeiden, indem Sie zwei Threads erstellen und die Ausgabe jedes Datenstroms in einem separaten Thread lesen.

Weitere Informationen

• StandardInput
• StandardOutput
• RedirectStandardError