Process.StandardOutput 속성

정의

애플리케이션의 텍스트 출력을 읽는 데 사용되는 스트림을 가져옵니다.Gets a stream used to read the textual output of the application.

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

속성 값

StreamReader

애플리케이션의 표준 출력 스트림을 읽는 데 사용할 수 있는 StreamReader입니다.A StreamReader that can be used to read the standard output stream of the application.

특성

예외

StandardOutput 스트림이 리디렉션에 대해 정의되지 않았습니다. RedirectStandardOutputtrue로 설정되고 UseShellExecutefalse로 설정되어 있는지 확인하세요.The StandardOutput stream has not been defined for redirection; ensure RedirectStandardOutput is set to true and UseShellExecute is set to false.

또는-or- StandardOutput 스트림이 BeginOutputReadLine()을 사용한 비동기 읽기 작업을 위해 열려 있습니다.The StandardOutput stream has been opened for asynchronous read operations with BeginOutputReadLine().

예제

다음 예제에서는 ipconfig.exe 명령을 실행 하 고 표준 출력을 예제의 콘솔 창으로 리디렉션합니다.The following example runs the ipconfig.exe command and redirects its standard output to the example's console window.

using namespace System;
using namespace System::IO;
using namespace System::Diagnostics;

int main()
{
    Process^ process = gcnew Process();
    process->StartInfo->FileName = "ipconfig.exe";
    process->StartInfo->UseShellExecute = false;
    process->StartInfo->RedirectStandardOutput = true;
    process->Start();

    // Synchronously read the standard output of the spawned process-> 
    StreamReader^ reader = process->StandardOutput;
    String^ output = reader->ReadToEnd();

    // Write the redirected output to this application's window.
    Console::WriteLine(output);

    process->WaitForExit();
    process->Close();

    Console::WriteLine("\n\nPress any key to exit");
    Console::ReadLine();
    return 0;
}
using System;
using System.IO;
using System.Diagnostics;

class StandardOutputExample
{
    public static void Main()
    {
        using (Process process = new Process())
        {
            process.StartInfo.FileName = "ipconfig.exe";
            process.StartInfo.UseShellExecute = false;
            process.StartInfo.RedirectStandardOutput = true;
            process.Start();

            // Synchronously read the standard output of the spawned process.
            StreamReader reader = process.StandardOutput;
            string output = reader.ReadToEnd();

            // Write the redirected output to this application's window.
            Console.WriteLine(output);

            process.WaitForExit();
        }

        Console.WriteLine("\n\nPress any key to exit.");
        Console.ReadLine();
    }
}
Imports System.IO
Imports System.Diagnostics

Module Module1
    Sub Main()
        Using process As New Process()
            process.StartInfo.FileName = "ipconfig.exe"
            process.StartInfo.UseShellExecute = False
            process.StartInfo.RedirectStandardOutput = True
            process.Start()

            ' Synchronously read the standard output of the spawned process. 
            Dim reader As StreamReader = process.StandardOutput
            Dim output As String = reader.ReadToEnd()
            Console.WriteLine(output)

            process.WaitForExit()
        End Using

        Console.WriteLine(Environment.NewLine + Environment.NewLine + "Press any key to exit.")
        Console.ReadLine()
    End Sub
End Module

설명

에서 Process 표준 스트림에 텍스트를 쓰면 해당 텍스트가 일반적으로 콘솔에 표시 됩니다.When a Process writes text to its standard stream, that text is normally displayed on the console. StandardOutput스트림을 리디렉션하여 프로세스의 출력을 조작 하거나 표시 하지 않을 수 있습니다.By redirecting 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.

참고

를 사용 하려면를로 StandardOutput 설정 ProcessStartInfo.UseShellExecutefalseProcessStartInfo.RedirectStandardOutput 를로 설정 true 해야 합니다.To use StandardOutput, you must set ProcessStartInfo.UseShellExecute to false, and you must set ProcessStartInfo.RedirectStandardOutput to true. 그렇지 않으면 StandardOutput 스트림에서 읽으면 예외가 throw 됩니다.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 StandardOutput 하거나 스트림을 닫을 때까지 완료 되지 않습니다.These 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. 이 메서드는 스트림 출력에 대해 지정 된 이벤트 처리기를 사용 하도록 설정 하 고 호출자에 게 즉시 반환 하 여 스트림 출력이 이벤트 처리기로 전달 되는 동안 다른 작업을 수행할 수 있습니다.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.

동기 읽기 작업은 스트림에서 읽은 호출자 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 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.

이 단원의 마지막 두 예제에서는 메서드를 사용 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. 또는 두 개의 스레드를 만들고 개별 스레드에서 각 스트림의 출력을 읽어 교착 상태 상태를 방지할 수 있습니다.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. 예를 들어, BeginOutputReadLine 스트림에서를 호출 ReadLine 하거나 그 반대의 경우에는 다음을 수행 하지 마십시오 StandardOutput .For example, do not follow BeginOutputReadLine with a call to ReadLine on the StandardOutput stream, or vice versa. 그러나 다른 모드에서는 서로 다른 두 스트림을 읽을 수 있습니다.However, you can read two different streams in different modes. 예를 들어를 호출한 BeginOutputReadLine 다음 스트림에 대해를 호출할 수 있습니다 ReadLine StandardError .For example, you can call BeginOutputReadLine and then call ReadLine for the StandardError stream.

적용 대상

추가 정보