Process.StandardError Właściwość

Definicja

Przestrzeń nazw:

System.Diagnostics

Zestaw:

System.Diagnostics.Process.dll

Źródło:

Process.cs

Pobiera strumień używany do odczytywania danych wyjściowych błędu aplikacji.

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

Wartość właściwości

StreamReader

Element StreamReader , który może służyć do odczytywania standardowego strumienia błędów aplikacji.

Wyjątki

InvalidOperationException

Strumień StandardError nie został zdefiniowany dla przekierowania; upewnij się RedirectStandardError , że ustawiono wartość true i UseShellExecute ustawiono wartość false.

-lub-

Strumień StandardError został otwarty dla asynchronicznych operacji odczytu za pomocą polecenia BeginErrorReadLine().

Przykłady

W poniższym przykładzie użyto net use polecenia razem z argumentem podanym przez użytkownika, aby zamapować zasób sieciowy. Następnie odczytuje standardowy strumień błędów polecenia net i zapisuje go w konsoli.

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

Uwagi

Process Gdy tekst jest zapisywany w standardowym strumieniu błędów, tekst jest zwykle wyświetlany w konsoli. Przekierowując StandardError strumień, można manipulować lub pomijać dane wyjściowe błędu procesu. Można na przykład filtrować tekst, formatować go inaczej lub zapisywać dane wyjściowe zarówno w konsoli, jak i w wyznaczonym pliku dziennika.

Uwaga

Aby użyć StandardErrorelementu , musisz ustawić falsewartość ProcessStartInfo.UseShellExecute i musisz ustawić truewartość ProcessStartInfo.RedirectStandardError . W przeciwnym razie odczyt ze strumienia StandardError zgłasza wyjątek.

Przekierowany StandardError strumień można odczytywać synchronicznie lub asynchronicznie. Metody takie jak Read, ReadLinei ReadToEnd wykonują synchroniczne operacje odczytu na strumieniu danych wyjściowych błędu procesu. Te synchroniczne operacje odczytu nie są wykonywane, dopóki skojarzony z nim ProcessStandardError zapis nie zostanie zamknięty lub nie zamknie strumienia.

Z kolei BeginErrorReadLine operacje odczytu asynchronicznego są uruchamiane w strumieniu StandardError . Ta metoda umożliwia wyznaczoną procedurę obsługi zdarzeń dla danych wyjściowych strumienia i natychmiast wraca do elementu wywołującego, co może wykonać inną pracę, gdy dane wyjściowe strumienia są kierowane do programu obsługi zdarzeń.

Synchroniczne operacje odczytu wprowadzają zależność między odczytywaniem elementu wywołującego ze strumienia StandardError a procesem podrzędnym zapisu w tym strumieniu. Te zależności mogą powodować warunki zakleszczenia. Gdy obiekt wywołujący odczytuje z przekierowanego strumienia procesu podrzędnego, jest on zależny od elementu podrzędnego. Obiekt wywołujący czeka na operację odczytu do momentu zapisania podrzędnego do strumienia lub zamknięcia strumienia. Gdy proces podrzędny zapisuje wystarczającą ilość danych, aby wypełnić przekierowany strumień, jest zależny od elementu nadrzędnego. Proces podrzędny czeka na następną operację zapisu, dopóki element nadrzędny nie odczytuje z pełnego strumienia lub zamknie strumień. Warunek zakleszczenia powoduje, że wywołanie i proces podrzędny czekają na siebie nawzajem, aby ukończyć operację, i nie można kontynuować. Można uniknąć zakleszczeń, oceniając zależności między obiektem wywołującym a procesem podrzędnym.

W dwóch ostatnich przykładach w tej sekcji użyto Start metody , aby uruchomić plik wykonywalny o nazwie Write500Lines.exe. Poniższy przykład zawiera kod źródłowy.

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.

W poniższym przykładzie pokazano, jak odczytywać dane ze strumienia błędu przekierowanego i czekać na zakończenie procesu podrzędnego. Pozwala uniknąć stanu zakleszczenia przez wywołanie p.StandardError.ReadToEnd metody przed p.WaitForExit. Warunek zakleszczenia może spowodować wywołanie p.WaitForExit procesu nadrzędnego przed i p.StandardError.ReadToEnd proces podrzędny zapisuje wystarczająco dużo tekstu, aby wypełnić przekierowany strumień. Proces nadrzędny będzie czekać na zakończenie procesu podrzędnego przez czas nieokreślony. Proces podrzędny czekałby na czas nieokreślony, aż element nadrzędny będzie odczytywał z pełnego StandardError strumienia.

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.

Podobny problem występuje podczas odczytywania całego tekstu zarówno ze standardowych strumieni danych wyjściowych, jak i standardowych błędów. Poniższy przykład wykonuje operację odczytu na obu strumieniach. Pozwala uniknąć warunku zakleszczenia, wykonując asynchroniczne operacje odczytu w strumieniu StandardError . Warunek zakleszczenia jest wynikiem wywołań p.StandardOutput.ReadToEnd procesu nadrzędnego, po którym następuje p.StandardError.ReadToEnd proces podrzędny, a proces podrzędny zapisuje wystarczająco dużo tekstu, aby wypełnić strumień błędu. Proces nadrzędny będzie czekać na czas nieokreślony, aż proces podrzędny zamknie strumień StandardOutput . Proces podrzędny czekałby na czas nieokreślony, aż element nadrzędny będzie odczytywał z pełnego StandardError strumienia.

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.

Możesz użyć asynchronicznych operacji odczytu, aby uniknąć tych zależności i ich potencjału zakleszczenia. Alternatywnie można uniknąć stanu zakleszczenia, tworząc dwa wątki i odczytując dane wyjściowe każdego strumienia w osobnym wątku.

Uwaga

Nie można mieszać asynchronicznych i synchronicznych operacji odczytu na przekierowanym strumieniu. Po otwarciu przekierowanego strumienia obiektu Process w trybie asynchronicznym lub synchronicznym wszystkie dalsze operacje odczytu na tym strumieniu muszą być w tym samym trybie. Na przykład nie należy wykonywać wywołania BeginErrorReadLine metody ReadLine w strumieniu StandardError ani odwrotnie. Można jednak odczytywać dwa różne strumienie w różnych trybach. Możesz na przykład wywołać BeginOutputReadLine metodę , a następnie wywołać ReadLineStandardError strumień.

Zobacz też

• StandardInput
• StandardOutput
• RedirectStandardError