ProcessStartInfo.RedirectStandardOutput Vlastnost

  • Reference

Definice

Obor názvů:
System.Diagnostics
Sestavení:
System.Diagnostics.Process.dll
Sestavení:
System.dll
Sestavení:
netstandard.dll
Zdroj:
ProcessStartInfo.cs
Zdroj:
ProcessStartInfo.cs
Zdroj:
ProcessStartInfo.cs

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

public:
 property bool RedirectStandardOutput { bool get(); void set(bool value); };
public bool RedirectStandardOutput { get; set; }
member this.RedirectStandardOutput : bool with get, set
Public Property RedirectStandardOutput As Boolean

Hodnota vlastnosti

Boolean

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

Příklady

// Run "cl.exe /cld stdstr.cpp /link /out:sample.exe". UseShellExecute is false because we're specifying
// an executable directly and in this case depending on it being in a PATH folder. By setting
// RedirectStandardOutput to true, the output of cl.exe is directed to the Process.StandardOutput stream
// which is then displayed in this console window directly.    
Process^ compiler = gcnew Process;
compiler->StartInfo->FileName = "cl.exe";
compiler->StartInfo->Arguments = "/clr stdstr.cpp /link /out:sample.exe";
compiler->StartInfo->UseShellExecute = false;
compiler->StartInfo->RedirectStandardOutput = true;
compiler->Start();

Console::WriteLine( compiler->StandardOutput->ReadToEnd() );

compiler->WaitForExit();

// Run "csc.exe /r:System.dll /out:sample.exe stdstr.cs". UseShellExecute is false because we're specifying
// an executable directly and in this case depending on it being in a PATH folder. By setting
// RedirectStandardOutput to true, the output of csc.exe is directed to the Process.StandardOutput stream
// which is then displayed in this console window directly.
using (Process compiler = new Process())
{
    compiler.StartInfo.FileName = "csc.exe";
    compiler.StartInfo.Arguments = "/r:System.dll /out:sample.exe stdstr.cs";
    compiler.StartInfo.UseShellExecute = false;
    compiler.StartInfo.RedirectStandardOutput = true;
    compiler.Start();

    Console.WriteLine(compiler.StandardOutput.ReadToEnd());

    compiler.WaitForExit();
}

' Run "vbc.exe /reference:Microsoft.VisualBasic.dll /out:sample.exe stdstr.vb". UseShellExecute is False 
' because we're specifying an executable directly and in this case depending on it being in a PATH folder. 
' By setting RedirectStandardOutput to True, the output of csc.exe is directed to the Process.StandardOutput 
' stream which is then displayed in this console window directly.    
Using compiler As New Process()
    compiler.StartInfo.FileName = "vbc.exe"
    compiler.StartInfo.Arguments = "/reference:Microsoft.VisualBasic.dll /out:sample.exe stdstr.vb"
    compiler.StartInfo.UseShellExecute = False
    compiler.StartInfo.RedirectStandardOutput = True
    compiler.Start()

    Console.WriteLine(compiler.StandardOutput.ReadToEnd())

    compiler.WaitForExit()
End Using

Poznámky

Když objekt Process zapisuje text do svého standardního streamu, obvykle se tento text zobrazí v konzole nástroje . RedirectStandardOutput Nastavením na true přesměrování datového StandardOutput proudu můžete manipulovat s výstupem procesu nebo s ním potlačit. 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 RedirectStandardOutput na true. V opačném případě čtení ze streamu StandardOutput vyvolá výjimku.

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

Naproti tomu BeginOutputReadLine spustí asynchronní operace čtení u datového StandardOutput proudu. Tato metoda povolí určenou obslužnou rutinu události (viz OutputDataReceived) pro výstup datového proudu a okamžitě se vrátí volajícímu, který může provádět 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 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 StandardOutput 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 a čekat na ukončení podřízeného procesu. V příkladu se vyhneme konfliktu vzájemného zablokování voláním p.StandardOutput.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.StandardOutput.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 StandardOutput datového proudu.

using System;
using System.Diagnostics;

public class Example2
{
   public static void Main()
   {
      var p = new Process();  
      p.StartInfo.UseShellExecute = false;  
      p.StartInfo.RedirectStandardOutput = true;  
      p.StartInfo.FileName = "Write500Lines.exe";  
      p.Start();  

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

      Console.WriteLine($"The last 50 characters in the output stream are:\n'{output.Substring(output.Length - 50)}'");
   }
}
// The example displays the following output:
//      Successfully wrote 500 lines.
//
//      The last 50 characters in the output stream are:
//      ' 49,800.20%
//      Line 500 of 500 written: 49,900.20%
//      '

Imports System.Diagnostics'

Public Module Example
   Public Sub Main()
      Dim p As New Process()
      p.StartInfo.UseShellExecute = False  
      p.StartInfo.RedirectStandardOutput = 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.StandardOutput.ReadToEnd()  
      p.WaitForExit()

      Console.WriteLine($"The last 50 characters in the output stream are:\n'{output.Substring(output.Length - 50)}'")
   End Sub
End Module
' The example displays the following output:
'      Successfully wrote 500 lines.
'
'      The last 50 characters in the output stream are:
'      ' 49,800.20%
'      Line 500 of 500 written: 49,900.20%
'      '

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ě.

Platí pro

Viz také