ProcessStartInfo.RedirectStandardError ProcessStartInfo.RedirectStandardError ProcessStartInfo.RedirectStandardError ProcessStartInfo.RedirectStandardError Property

定義

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

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

プロパティ値

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

次の例ではnet use 、ユーザーが指定した引数と共にコマンドを使用して、ネットワークリソースをマップします。The following example uses the net use command together with a user-supplied argument to map a network resource. 次に、net コマンドの標準エラーストリームを読み取り、コンソールに書き込みます。It then reads the standard error stream of the net command and writes it to console.

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

注釈

Processテキストを標準エラーストリームに書き込む場合、そのテキストは通常、コンソールに表示されます。When a Process writes text to its standard error stream, that text is typically displayed on the console. StandardErrorストリームをリダイレクトすることにより、プロセスのエラー出力を操作または非表示にすることができます。By redirecting the StandardError stream, you can manipulate or suppress the error 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 設定するRedirectStandardError場合は、をに設定する必要があります。 trueYou must set UseShellExecute to false if you want to set RedirectStandardError to true. それ以外の場合、 StandardErrorストリームからの読み取りでは例外がスローされます。Otherwise, reading from the StandardError stream throws an exception.

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

これに対しBeginErrorReadLine StandardErrorて、は、ストリームに対して非同期の読み取り操作を開始します。In contrast, BeginErrorReadLine starts asynchronous read operations on the StandardError stream. このメソッドは、ストリーム出力に対して指定されたイベントハンドラーを有効にし、すぐに呼び出し元に戻します。これにより、ストリーム出力がイベントハンドラーに送られている間に他の処理を実行できます。This method enables a designated event handler 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.

注意

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

同期読み取り操作では、 StandardErrorストリームから読み取った呼び出し元と、そのストリームに書き込む子プロセスとの間に依存関係が生じます。Synchronous read operations introduce a dependency between the caller reading from the StandardError 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という名前の実行可能ファイルを起動します。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 error stream and wait for the child process to exit. これは、の前にp.StandardError.ReadToEnd p.WaitForExitを呼び出すことによって、デッドロック状態を回避します。It avoids a deadlock condition by calling p.StandardError.ReadToEnd before p.WaitForExit. デッドロック状態が発生するのは、親p.WaitForExitプロセスp.StandardError.ReadToEndがを呼び出してから、子プロセスがリダイレクトされたストリームを埋めるために十分なテキストを書き込む場合です。A deadlock condition can result if the parent process calls p.WaitForExit before p.StandardError.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. 子プロセスは、親が完全な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.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.

標準出力と標準エラーストリームの両方からすべてのテキストを読み取ると、同様の問題が発生します。There is a similar issue when you read all text from both the standard output and standard error streams. たとえば、 C#次のコードでは、両方のストリームに対して読み取り操作を実行します。The following C# code, for 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.

適用対象

こちらもご覧ください