ProcessStartInfo.RedirectStandardOutput プロパティ

定義

アプリケーションのテキスト出力を StandardOutput ストリームに書き込むかどうかを示す値を取得または設定します。Gets or sets a value that indicates whether the textual output of an application is written to the StandardOutput stream.

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

プロパティ値

Boolean

出力を StandardOutput に書き込む場合は true。それ以外の場合は falsetrue if output should be written to StandardOutput; otherwise, false. 既定値は、false です。The default is false.

// 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

注釈

Process テキストを標準ストリームに書き込む場合、そのテキストは通常、コンソールに表示されます。When a Process writes text to its standard stream, that text is typically displayed on the console. をに設定してストリームをリダイレクトすることで、 RedirectStandardOutput true StandardOutput プロセスの出力を操作または非表示にすることができます。By setting RedirectStandardOutput to true to redirect the StandardOutput stream, you can manipulate or suppress the output of a process. たとえば、テキストをフィルター処理したり、異なる形式を設定したり、コンソールと指定したログファイルの両方に出力を書き込むことができます。For example, you can filter the text, format it differently, or write the output to both the console and a designated log file.

注意

UseShellExecuteをに設定する場合は、をに設定する必要があり false RedirectStandardOutput true ます。You must set UseShellExecute to false if you want to set RedirectStandardOutput to true. それ以外の場合、ストリームからの読み取りでは StandardOutput 例外がスローされます。Otherwise, reading from the StandardOutput stream throws an exception.

リダイレクトされたストリームは、 StandardOutput 同期的または非同期的に読み取ることができます。The redirected StandardOutput stream can be read synchronously or asynchronously. 、、などのメソッド Read ReadLine は、 ReadToEnd プロセスの出力ストリームに対して同期読み取り操作を実行します。Methods such as Read, ReadLine, and ReadToEnd perform synchronous read operations on the output stream of the process. これらの同期読み取り操作は、関連付けられているストリームへの書き込みが完了するまで、 Process またはストリームを閉じるまで完了しません StandardOutputThese synchronous read operations do not complete until the associated Process writes to its StandardOutput stream, or closes the stream.

これに対して、は、 BeginOutputReadLine ストリームに対して非同期の読み取り操作を開始 StandardOutput します。In contrast, BeginOutputReadLine starts asynchronous read operations on the StandardOutput stream. このメソッドは、ストリーム出力に対して指定されたイベントハンドラー (を参照) を有効に OutputDataReceived し、すぐに呼び出し元に戻します。これにより、ストリーム出力がイベントハンドラーに送られている間に、他の処理を実行できます。This method enables a designated event handler (see OutputDataReceived) for the stream output and immediately returns to the caller, which can perform other work while the stream output is directed to the event handler.

注意

非同期出力を処理するアプリケーションでは、 WaitForExit 出力バッファーがフラッシュされたことを確認するためにメソッドを呼び出す必要があります。The application that is processing the asynchronous output should call the WaitForExit method to ensure that the output buffer has been flushed.

同期読み取り操作では、ストリームから読み取った呼び出し元 StandardOutput と、そのストリームに書き込む子プロセスとの間に依存関係が生じます。Synchronous read operations introduce a dependency between the caller reading from the StandardOutput stream and the child process writing to that stream. これらの依存関係により、デッドロック状態が発生する可能性があります。These dependencies can cause deadlock conditions. 呼び出し元が子プロセスのリダイレクトされたストリームから読み取る場合は、子に依存します。When the caller reads from the redirected stream of a child process, it is dependent on the child. 呼び出し元は、子がストリームに書き込むかストリームを閉じるまで、読み取り操作を待機します。The caller waits for the read operation until the child writes to the stream or closes the stream. 子プロセスは、リダイレクトされたストリームを埋めるために十分なデータを書き込むときに、親に依存します。When the child process writes enough data to fill its redirected stream, it is dependent on the parent. 子プロセスは、親が完全なストリームから読み取るか、ストリームを閉じるまで、次の書き込み操作を待機します。The child process waits for the next write operation until the parent reads from the full stream or closes the stream. デッドロック状態は、呼び出し元と子プロセスが相互に操作を完了するのを待機していて、どちらも続行できない場合に発生します。The deadlock condition results when the caller and child process wait for each other to complete an operation, and neither can continue. 呼び出し元と子プロセスの間の依存関係を評価することによって、デッドロックを回避できます。You can avoid deadlocks by evaluating dependencies between the caller and child process.

このセクションの最後の2つの例では、メソッドを使用して、 Start Write500Lines.exe という名前の実行可能ファイルを起動します。The last two examples in this section use the Start method to launch an executable named Write500Lines.exe. 次の例には、ソースコードが含まれています。The following example contains its source code.

using System;
using System.IO;

public class Example
{
   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.

次の例は、リダイレクトされたストリームから読み取り、子プロセスが終了するまで待機する方法を示しています。The following example shows how to read from a redirected stream and wait for the child process to exit. この例では、の前にを呼び出すことにより、デッドロック状態を回避し p.StandardOutput.ReadToEnd p.WaitForExit ます。The example avoids a deadlock condition by calling p.StandardOutput.ReadToEnd before p.WaitForExit. デッドロック状態が発生するのは、親プロセスがを呼び出してから、 p.WaitForExit p.StandardOutput.ReadToEnd 子プロセスがリダイレクトされたストリームを埋めるために十分なテキストを書き込む場合です。A deadlock condition can result if the parent process calls p.WaitForExit before p.StandardOutput.ReadToEnd and the child process writes enough text to fill the redirected stream. 親プロセスは、子プロセスが終了するまで無期限に待機します。The parent process would wait indefinitely for the child process to exit. 子プロセスは、親が完全なストリームから読み取るまで無制限に待機し StandardOutput ます。The child process would wait indefinitely for the parent to read from the full StandardOutput stream.

using System;
using System.Diagnostics;

public class Example
{
   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%
'      '

標準出力と標準エラーストリームの両方からすべてのテキストを読み取ると、同様の問題が発生します。There is a similar issue when you read all text from both the standard output and standard error streams. 次の例では、両方のストリームに対して読み取り操作を実行します。The following example performs a read operation on both streams. ストリームに対して非同期の読み取り操作を実行することで、デッドロック状態を回避し StandardError ます。It avoids the deadlock condition by performing asynchronous read operations on the StandardError stream. デッドロック状態が発生するのは、親プロセスがを呼び出した p.StandardOutput.ReadToEnd 後で p.StandardError.ReadToEnd 、子プロセスがエラーストリームを埋めるために十分なテキストを書き込む場合です。A deadlock condition results if the parent process calls p.StandardOutput.ReadToEnd followed by p.StandardError.ReadToEnd and the child process writes enough text to fill its error stream. 親プロセスは、子プロセスがそのストリームを閉じるまで無期限に待機し StandardOutput ます。The parent process would wait indefinitely for the child process to close its StandardOutput stream. 子プロセスは、親が完全なストリームから読み取るまで無制限に待機し StandardError ます。The child process would wait indefinitely for the parent to read from the full StandardError stream.

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.

非同期の読み取り操作を使用すると、これらの依存関係とデッドロックの可能性を回避できます。You can use asynchronous read operations to avoid these dependencies and their deadlock potential. または、2つのスレッドを作成し、各ストリームの出力を個別のスレッドで読み取ることによって、デッドロック状態を回避できます。Alternately, you can avoid the deadlock condition by creating two threads and reading the output of each stream on a separate thread.

適用対象

こちらもご覧ください