ProcessStartInfo.RedirectStandardError Vlastnost

Definice

Obor názvů:

System.Diagnostics

Sestavení:

System.Diagnostics.Process.dll

Zdroj:

ProcessStartInfo.cs

Získá nebo nastaví hodnotu, která označuje, zda je výstup chyby aplikace zapsán do datového StandardError proudu.

public:
 property bool RedirectStandardError { bool get(); void set(bool value); };

public bool RedirectStandardError { get; set; }

member this.RedirectStandardError : bool with get, set

Public Property RedirectStandardError As Boolean

Hodnota vlastnosti

Boolean

truepokud má být výstup chyby zapsán do StandardError, jinak . false Výchozí formát je false.

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 svého 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 nastavit UseShellExecute na false , musíte nastavit RedirectStandardError 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 Readje , ReadLine a 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.

Poznámka

Aplikace, která zpracovává asynchronní výstup, by měla volat metodu Process.WaitForExit , aby se zajistilo, že výstupní vyrovnávací paměť byla vyprázdněna.

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 způsobit podmínky 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í čeká 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ý objekt nepřečte z úplného datového proudu nebo datový proud nezavře. Výsledkem konfliktu zablokování je, že volající a podřízený proces čekají na dokončení operace navzájem a žádný z nich 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í kód jazyka C# například provádí 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ě.

Viz také

• UseShellExecute
• StandardError