Sdílet prostřednictvím


Process.StandardError Vlastnost

Definice

Získá datový proud sloužící ke čtení výstupu chyby aplikace.

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

Hodnota vlastnosti

Objekt , StreamReader který lze použít ke čtení standardního chybového proudu aplikace.

Atributy

Výjimky

Datový StandardError proud nebyl definován pro přesměrování. Ujistěte se, že RedirectStandardError je nastavená hodnota true a UseShellExecute nastavená na falsehodnotu .

-nebo-

Datový StandardError proud byl otevřen pro asynchronní operace čtení pomocí BeginErrorReadLine().

Příklady

Následující příklad používá net use příkaz společně s uživatelem zadaným argumentem k mapování síťového prostředku. Pak přečte standardní datový proud chyb příkazu net a zapíše ho do konzoly.

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

Poznámky

Když objekt Process zapisuje text do standardního proudu chyb, obvykle se tento text zobrazí v konzole nástroje . Přesměrováním datového StandardError proudu můžete manipulovat nebo potlačit výstup chyby procesu. Můžete například filtrovat text, jinak ho formátovat nebo zapsat výstup do konzoly a určeného souboru protokolu.

Poznámka

Pokud chcete použít StandardError, musíte nastavit ProcessStartInfo.UseShellExecute na falsea ProcessStartInfo.RedirectStandardError pak na true. V opačném případě čtení ze streamu StandardError vyvolá výjimku.

Přesměrovaný StandardError datový proud lze číst synchronně nebo asynchronně. Metody jako Read, ReadLinea ReadToEnd provádějí synchronní operace čtení ve výstupním datovém proudu chyb procesu. Tyto synchronní operace čtení se nedokončí, dokud přidružený Process datový proud nezapíše nebo StandardError neukončí datový proud.

Naproti tomu BeginErrorReadLine spustí asynchronní operace čtení u datového StandardError proudu. Tato metoda povolí určenou obslužnou rutinu události pro výstup datového proudu a okamžitě se vrátí volajícímu, který může provést jinou práci, zatímco výstup datového proudu je směrován na obslužnou rutinu události.

Synchronní operace čtení představují závislost mezi volajícím, který čte z datového proudu, a podřízeným procesem, který do tohoto datového StandardError proudu zapisuje. Tyto závislosti můžou vést k podmínkám vzájemného zablokování. Když volající čte z přesměrovaného datového proudu podřízeného procesu, závisí to na podřízené sadě. Volající počká na operaci čtení, dokud podřízený datový proud nezapíše nebo datový proud nezavře. Když podřízený proces zapíše dostatek dat k vyplnění přesměrovaného datového proudu, závisí na nadřazené. Podřízený proces čeká na další operaci zápisu, dokud nadřazený datový proud nepřečte z úplného datového proudu nebo datový proud nezavře. Výsledkem konfliktu vzájemného zablokování je, že volající a podřízený proces čekají na dokončení operace a nemůže pokračovat. Vzájemnému zablokování se můžete vyhnout vyhodnocením závislostí mezi volajícím a podřízeným procesem.

Poslední dva příklady v této části používají metodu Start ke spuštění spustitelného souboru s názvemWrite500Lines.exe. Následující příklad obsahuje jeho zdrojový kód.

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.

Následující příklad ukazuje, jak číst z přesměrovaného datového proudu chyb a čekat na ukončení podřízeného procesu. Vyhne se konfliktu vzájemného zablokování voláním p.StandardError.ReadToEnd metody před p.WaitForExit. Podmínka vzájemného zablokování může být výsledkem, pokud nadřazený proces volá p.WaitForExit před p.StandardError.ReadToEnd a podřízený proces zapíše dostatek textu k vyplnění přesměrovaného datového proudu. Nadřazený proces by čekal neurčitou dobu na ukončení podřízeného procesu. Podřízený proces by po neomezenou dobu čekal na načtení nadřazeného datového proudu z úplného StandardError datového proudu.

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.

K podobnému problému dochází při čtení veškerého textu ze standardního výstupního i standardního chybového proudu. Následující příklad provede operaci čtení v obou datových proudech. Vyhne se konfliktu vzájemného zablokování prováděním asynchronních operací čtení datového StandardError proudu. Výsledkem konfliktu vzájemného zablokování je volání p.StandardOutput.ReadToEnd nadřazeného procesu, po p.StandardError.ReadToEnd kterém následuje a podřízený proces zapíše dostatečný text, aby vyplnil svůj datový proud chyb. Nadřazený proces bude čekat neomezeně dlouho, než podřízený proces zavře svůj StandardOutput datový proud. Podřízený proces by po neomezenou dobu čekal na načtení nadřazeného datového proudu z úplného StandardError datového proudu.

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.

Pomocí asynchronních operací čtení se můžete těmto závislostem a jejich potenciálu vzájemného zablokování vyhnout. Případně se můžete konfliktu vzájemného zablokování vyhnout vytvořením dvou vláken a přečtením výstupu každého datového proudu v samostatném vlákně.

Poznámka

U přesměrovaného datového proudu nelze kombinovat asynchronní a synchronní operace čtení. Po otevření přesměrovaného datového proudu v asynchronním nebo synchronním režimu musí být všechny další operace čtení u tohoto datového Process proudu ve stejném režimu. Nesledujte BeginErrorReadLine například voláním ReadLine ve streamu StandardError nebo naopak. Můžete ale číst dva různé datové proudy v různých režimech. Můžete například volat BeginOutputReadLine a pak volat ReadLine datový StandardError proud.

Platí pro

Viz také