ProcessStartInfo.RedirectStandardError 속성

정의

애플리케이션의 오류 출력을 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

속성 값

Boolean

오류 출력을true 에 써야 하는 경우 StandardError이고, 그러지 않으면 false입니다.true 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 true .You must set UseShellExecute to false if you want to set RedirectStandardError to true. 그렇지 않으면 StandardError 스트림에서 읽으면 예외가 throw 됩니다.Otherwise, reading from the StandardError stream throws an exception.

리디렉션된 StandardError 스트림은 동기적 또는 비동기적으로 읽을 수 있습니다.The redirected StandardError stream can be read synchronously or asynchronously. 등의 메서드 ReadReadLine ReadToEnd 프로세스의 오류 출력 스트림에 대해 동기 읽기 작업을 수행 합니다.Methods 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.

이 단원의 마지막 두 예제에서는 메서드를 사용 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 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. 또는 두 개의 스레드를 만들고 개별 스레드에서 각 스트림의 출력을 읽어 교착 상태 상태를 방지할 수 있습니다.Alternately, you can avoid the deadlock condition by creating two threads and reading the output of each stream on a separate thread.

적용 대상

추가 정보