Process.StandardError プロパティ

定義

アプリケーションのエラー出力の読み取りに使用されるストリームを取得します。Gets a stream used to read the error output of the application.

public:
 property System::IO::StreamReader ^ StandardError { System::IO::StreamReader ^ get(); };
[System.ComponentModel.Browsable(false)]
public System.IO.StreamReader StandardError { get; }
member this.StandardError : System.IO.StreamReader
Public ReadOnly Property StandardError As StreamReader

プロパティ値

アプリケーションの標準エラー ストリームの読み取りに使用できる StreamReaderA StreamReader that can be used to read the standard error stream of the application.

属性

例外

StandardError ストリームがリダイレクト用に定義されていません。RedirectStandardErrortrue に設定されており、UseShellExecutefalse に設定されていることを確認してください。The StandardError stream has not been defined for redirection; ensure RedirectStandardError is set to true and UseShellExecute is set to false.

- または --or- StandardError ストリームが、BeginErrorReadLine() を使用した非同期読み取り操作のために開いています。The StandardError stream has been opened for asynchronous read operations with BeginErrorReadLine().

次の例では、ユーザーが指定した引数と共に 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 normally 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.

注意

StandardErrorを使用するには、ProcessStartInfo.UseShellExecutefalseに設定し、ProcessStartInfo.RedirectStandardErrortrueに設定する必要があります。To use StandardError, you must set ProcessStartInfo.UseShellExecute to false, and you must set ProcessStartInfo.RedirectStandardError to true. それ以外の場合、StandardError ストリームからの読み取りでは、例外がスローされます。Otherwise, reading from the StandardError stream throws an exception.

リダイレクトされた StandardError ストリームは、同期または非同期で読み取ることができます。The redirected StandardError stream can be read synchronously or asynchronously. ReadReadLineReadToEnd などのメソッドは、プロセスのエラー出力ストリームに対して同期読み取り操作を実行します。Methods such as Read, ReadLine, and ReadToEnd perform synchronous read operations on the error output stream of the process. これらの同期読み取り操作は、関連付けられた ProcessStandardError ストリームに書き込むか、ストリームを閉じるまで完了しません。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.

同期読み取り操作では、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 result in deadlock conditions. 呼び出し元が子プロセスのリダイレクトされたストリームから読み取る場合は、子に依存します。When the caller reads from the redirected stream of a child process, it is dependent on the child. 呼び出し元は、読み取り操作で、子がストリームに書き込むか、ストリームを閉じるまで待機します。The caller waits on 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 on 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 on each other to complete an operation, and neither can proceed. 呼び出し元と子プロセスの間の依存関係を評価することによって、デッドロックを回避できます。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.WaitForExitする前に p.StandardError.ReadToEnd を呼び出すことによって、デッドロック状態を回避します。It avoids a deadlock condition by calling p.StandardError.ReadToEnd before p.WaitForExit. デッドロック状態が発生するのは、親プロセスが p.StandardError.ReadToEnd より前に p.WaitForExit を呼び出し、子プロセスが、リダイレクトされたストリームを埋めるために十分なテキストを書き込む場合です。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. 次の例では、両方のストリームに対して読み取り操作を実行します。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.

注意

リダイレクトされたストリームでは、非同期および同期読み取り操作を混在させることはできません。You cannot mix asynchronous and synchronous read operations on a redirected stream. Process のリダイレクトされたストリームを非同期モードまたは同期モードで開くと、そのストリームでのすべての読み取り操作は同じモードである必要があります。Once the redirected stream of a Process is opened in either asynchronous or synchronous mode, all further read operations on that stream must be in the same mode. たとえば、StandardError ストリームで ReadLine を呼び出すことによって BeginErrorReadLine に従わないでください。その逆も同様です。For example, do not follow BeginErrorReadLine with a call to ReadLine on the StandardError stream, or vice versa. ただし、異なるモードの2つの異なるストリームを読み取ることができます。However, you can read two different streams in different modes. たとえば、BeginOutputReadLine を呼び出し、StandardError ストリームの ReadLine を呼び出すことができます。For example, you can call BeginOutputReadLine and then call ReadLine for the StandardError stream.

セキュリティ

LinkDemand
直前の呼び出し元に対する完全な信頼の場合。for full trust for the immediate caller. このメンバーは、部分的に信頼されているコードから使用することはできません。This member cannot be used by partially trusted code.

適用対象

こちらもご覧ください