次の方法で共有

Process.BeginOutputReadLine メソッド

  • リファレンス

定義

名前空間:
System.Diagnostics
アセンブリ:
System.Diagnostics.Process.dll
アセンブリ:
System.dll
アセンブリ:
netstandard.dll
ソース:
Process.cs
ソース:
Process.cs
ソース:
Process.cs

アプリケーションのリダイレクトされた StandardOutput ストリームで、非同期読み取り操作を開始します。

public:
 void BeginOutputReadLine();
public void BeginOutputReadLine ();
[System.Runtime.InteropServices.ComVisible(false)]
public void BeginOutputReadLine ();
member this.BeginOutputReadLine : unit -> unit
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.BeginOutputReadLine : unit -> unit
Public Sub BeginOutputReadLine ()
属性
ComVisibleAttribute

例外

InvalidOperationException

RedirectStandardOutput プロパティが false です。

または

StandardOutput ストリームで非同期読み取り操作は既に実行されています。

または

StandardOutput ストリームは、同期読み取り操作によって使用されています。

例

次の例は、 コマンドのリダイレクトされた StandardOutput ストリームに対して非同期読み取り操作を実行する方法を sort 示しています。 コマンドは sort 、テキスト入力を読み取って並べ替えるコンソール アプリケーションです。

この例では、イベント ハンドラーのイベント デリゲートを SortOutputHandler 作成し、イベントに OutputDataReceived 関連付けます。 イベント ハンドラーは、リダイレクトされた StandardOutput ストリームからテキスト行を受け取り、テキストの書式設定を行い、テキストを画面に書き込みます。

// Define the namespaces used by this sample.
#using <System.dll>

using namespace System;
using namespace System::Text;
using namespace System::IO;
using namespace System::Diagnostics;
using namespace System::Threading;
using namespace System::ComponentModel;

ref class SortOutputRedirection
{
private:
   // Define static variables shared by class methods.
   static StringBuilder^ sortOutput = nullptr;
   static int numOutputLines = 0;

public:
   static void SortInputListText()
   {
      // Initialize the process and its StartInfo properties.
      // The sort command is a console application that
      // reads and sorts text input.

      Process^ sortProcess;
      sortProcess = gcnew Process;
      sortProcess->StartInfo->FileName = "Sort.exe";
      
      // Set UseShellExecute to false for redirection.
      sortProcess->StartInfo->UseShellExecute = false;
      
      // Redirect the standard output of the sort command.  
      // This stream is read asynchronously using an event handler.
      sortProcess->StartInfo->RedirectStandardOutput = true;
      sortOutput = gcnew StringBuilder;
      
      // Set our event handler to asynchronously read the sort output.
      sortProcess->OutputDataReceived += gcnew DataReceivedEventHandler( SortOutputHandler );
      
      // Redirect standard input as well.  This stream
      // is used synchronously.
      sortProcess->StartInfo->RedirectStandardInput = true;
      
      // Start the process.
      sortProcess->Start();
      
      // Use a stream writer to synchronously write the sort input.
      StreamWriter^ sortStreamWriter = sortProcess->StandardInput;
      
      // Start the asynchronous read of the sort output stream.
      sortProcess->BeginOutputReadLine();
      
      // Prompt the user for input text lines.  Write each 
      // line to the redirected input stream of the sort command.
      Console::WriteLine( "Ready to sort up to 50 lines of text" );

      String^ inputText;
      int numInputLines = 0;
      do
      {
         Console::WriteLine( "Enter a text line (or press the Enter key to stop):" );

         inputText = Console::ReadLine();
         if (  !String::IsNullOrEmpty( inputText ) )
         {
            numInputLines++;
            sortStreamWriter->WriteLine( inputText );
         }
      }
      while (  !String::IsNullOrEmpty( inputText ) && (numInputLines < 50) );

      Console::WriteLine( "<end of input stream>" );
      Console::WriteLine();
      
      // End the input stream to the sort command.
      sortStreamWriter->Close();
      
      // Wait for the sort process to write the sorted text lines.
      sortProcess->WaitForExit();

      if ( numOutputLines > 0 )
      {
         
         // Write the formatted and sorted output to the console.
         Console::WriteLine( " Sort results = {0} sorted text line(s) ",
            numOutputLines.ToString() );
         Console::WriteLine( "----------" );
         Console::WriteLine( sortOutput->ToString() );
      }
      else
      {
         Console::WriteLine( " No input lines were sorted." );
      }

      sortProcess->Close();
   }

private:
   static void SortOutputHandler( Object^ /*sendingProcess*/,
      DataReceivedEventArgs^ outLine )
   {
      // Collect the sort command output.
      if (  !String::IsNullOrEmpty( outLine->Data ) )
      {
         numOutputLines++;
         
         // Add the text to the collected output.
         sortOutput->AppendFormat( "\n[{0}] {1}",
            numOutputLines.ToString(), outLine->Data );
      }
   }
};

/// The main entry point for the application.
void main()
{
   try
   {
      SortOutputRedirection::SortInputListText();
   }
   catch ( InvalidOperationException^ e ) 
   {
      Console::WriteLine( "Exception:" );
      Console::WriteLine( e );
   }
}

// Define the namespaces used by this sample.
using System;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.Threading;
using System.ComponentModel;

namespace ProcessAsyncStreamSamples
{
    class SortOutputRedirection
    {
        // Define static variables shared by class methods.
        private static StringBuilder sortOutput = null;
        private static int numOutputLines = 0;

        public static void SortInputListText()
        {
            // Initialize the process and its StartInfo properties.
            // The sort command is a console application that
            // reads and sorts text input.

            Process sortProcess = new Process();
            sortProcess.StartInfo.FileName = "Sort.exe";

            // Set UseShellExecute to false for redirection.
            sortProcess.StartInfo.UseShellExecute = false;

            // Redirect the standard output of the sort command.
            // This stream is read asynchronously using an event handler.
            sortProcess.StartInfo.RedirectStandardOutput = true;
            sortOutput = new StringBuilder();

            // Set our event handler to asynchronously read the sort output.
            sortProcess.OutputDataReceived += SortOutputHandler;

            // Redirect standard input as well.  This stream
            // is used synchronously.
            sortProcess.StartInfo.RedirectStandardInput = true;

            // Start the process.
            sortProcess.Start();

            // Use a stream writer to synchronously write the sort input.
            StreamWriter sortStreamWriter = sortProcess.StandardInput;

            // Start the asynchronous read of the sort output stream.
            sortProcess.BeginOutputReadLine();

            // Prompt the user for input text lines.  Write each
            // line to the redirected input stream of the sort command.
            Console.WriteLine("Ready to sort up to 50 lines of text");

            String inputText;
            int numInputLines = 0;
            do
            {
                Console.WriteLine("Enter a text line (or press the Enter key to stop):");

                inputText = Console.ReadLine();
                if (!String.IsNullOrEmpty(inputText))
                {
                    numInputLines++;
                    sortStreamWriter.WriteLine(inputText);
                }
            }
            while (!String.IsNullOrEmpty(inputText) && (numInputLines < 50));
            Console.WriteLine("<end of input stream>");
            Console.WriteLine();

            // End the input stream to the sort command.
            sortStreamWriter.Close();

            // Wait for the sort process to write the sorted text lines.
            sortProcess.WaitForExit();

            if (numOutputLines > 0)
            {
                // Write the formatted and sorted output to the console.
                Console.WriteLine($" Sort results = {numOutputLines} sorted text line(s) ");
                Console.WriteLine("----------");
                Console.WriteLine(sortOutput);
            }
            else
            {
                Console.WriteLine(" No input lines were sorted.");
            }

            sortProcess.Close();
        }

        private static void SortOutputHandler(object sendingProcess,
            DataReceivedEventArgs outLine)
        {
            // Collect the sort command output.
            if (!String.IsNullOrEmpty(outLine.Data))
            {
                numOutputLines++;

                // Add the text to the collected output.
                sortOutput.Append(Environment.NewLine +
                    $"[{numOutputLines}] - {outLine.Data}");
            }
        }
    }
}

namespace ProcessAsyncStreamSamples
{

    class ProcessSampleMain
    {
        /// The main entry point for the application.
        static void Main()
        {
            try
            {
                SortOutputRedirection.SortInputListText();
            }
            catch (InvalidOperationException e)
            {
                Console.WriteLine("Exception:");
                Console.WriteLine(e);
            }
        }
    }
}

' Define the namespaces used by this sample.
Imports System.Text
Imports System.IO
Imports System.Diagnostics
Imports System.Threading
Imports System.ComponentModel

Namespace ProcessAsyncStreamSamples

    Class ProcessAsyncOutputRedirection
        ' Define static variables shared by class methods.
        Private Shared sortOutput As StringBuilder = Nothing
        Private Shared numOutputLines As Integer = 0

        Public Shared Sub SortInputListText()

            ' Initialize the process and its StartInfo properties.
            ' The sort command is a console application that
            ' reads and sorts text input.
            Dim sortProcess As New Process()
            sortProcess.StartInfo.FileName = "Sort.exe"

            ' Set UseShellExecute to false for redirection.
            sortProcess.StartInfo.UseShellExecute = False

            ' Redirect the standard output of the sort command.  
            ' Read the stream asynchronously using an event handler.
            sortProcess.StartInfo.RedirectStandardOutput = True
            sortOutput = New StringBuilder()

            ' Set our event handler to asynchronously read the sort output.
            AddHandler sortProcess.OutputDataReceived, AddressOf SortOutputHandler

            ' Redirect standard input as well.  This stream
            ' is used synchronously.
            sortProcess.StartInfo.RedirectStandardInput = True

            ' Start the process.
            sortProcess.Start()

            ' Use a stream writer to synchronously write the sort input.
            Dim sortStreamWriter As StreamWriter = sortProcess.StandardInput

            ' Start the asynchronous read of the sort output stream.
            sortProcess.BeginOutputReadLine()

            ' Prompt the user for input text lines.  Write each 
            ' line to the redirected input stream of the sort command.
            Console.WriteLine("Ready to sort up to 50 lines of text")

            Dim inputText As String
            Dim numInputLines As Integer = 0
            Do
                Console.WriteLine("Enter a text line (or press the Enter key to stop):")

                inputText = Console.ReadLine()
                If Not String.IsNullOrEmpty(inputText) Then
                    numInputLines += 1
                    sortStreamWriter.WriteLine(inputText)
                End If
            Loop While Not String.IsNullOrEmpty(inputText) AndAlso numInputLines < 50
            Console.WriteLine("<end of input stream>")
            Console.WriteLine()

            ' End the input stream to the sort command.
            sortStreamWriter.Close()

            ' Wait for the sort process to write the sorted text lines.
            sortProcess.WaitForExit()

            If Not String.IsNullOrEmpty(numOutputLines) Then
                ' Write the formatted and sorted output to the console.
                Console.WriteLine($" Sort results = {numOutputLines} sorted text line(s) ")
                Console.WriteLine("----------")
                Console.WriteLine(sortOutput)
            Else
                Console.WriteLine(" No input lines were sorted.")
            End If

            sortProcess.Close()
        End Sub

        Private Shared Sub SortOutputHandler(sendingProcess As Object,
           outLine As DataReceivedEventArgs)

            ' Collect the sort command output.
            If Not String.IsNullOrEmpty(outLine.Data) Then
                numOutputLines += 1

                ' Add the text to the collected output.
                sortOutput.Append(Environment.NewLine +
                    $"[{numOutputLines}] - {outLine.Data}")
            End If
        End Sub
    End Class
End Namespace

Namespace ProcessAsyncStreamSamples

    Class ProcessSampleMain

        ' The main entry point for the application.
        Shared Sub Main()
            Try
                ProcessAsyncOutputRedirection.SortInputListText()

            Catch e As InvalidOperationException
                Console.WriteLine("Exception:")
                Console.WriteLine(e)
            End Try
        End Sub
    End Class  'ProcessSampleMain
End Namespace 'Process_AsyncStream_Sample

注釈

ストリームは StandardOutput 、同期的または非同期的に読み取ることができます。 、、 などのReadReadLineメソッドは、ReadToEndプロセスの出力ストリームに対して同期読み取り操作を実行します。 これらの同期読み取り操作は、関連付けられている Process がストリームへの書き込みを行うか、ストリームを StandardOutput 閉じるまで完了しません。

これに対し、 はストリーム BeginOutputReadLine に対する非同期読み取り操作を StandardOutput 開始します。 このメソッドは、ストリーム出力に対して指定されたイベント ハンドラーを有効にし、すぐに呼び出し元に戻り、ストリーム出力がイベント ハンドラーに送信されている間に他の作業を実行できます。

の非同期読み取り操作を実行するには、次の手順に StandardOutputProcess 従います。

  1. UseShellExecute を false に設定します。

  2. RedirectStandardOutput を true に設定します。

  3. イベント ハンドラーを イベントに OutputDataReceived 追加します。 イベント ハンドラーは、デリゲートシグネチャと一致する System.Diagnostics.DataReceivedEventHandler 必要があります。

  4. Process を開始します。

  5. を呼び出 BeginOutputReadLine します Process。 この呼び出しは、 で非同期読み取り操作を開始します StandardOutput。

非同期読み取り操作が開始されると、関連付けられた Process がストリームにテキスト行を書き込むたびにイベント ハンドラーが StandardOutput 呼び出されます。

を呼び出 CancelOutputReadすことで、非同期読み取り操作を取り消すことができます。 読み取り操作は、呼び出し元またはイベント ハンドラーによって取り消すことができます。 取り消した後、もう一度 を呼び出 BeginOutputReadLine して非同期読み取り操作を再開できます。

注意

リダイレクトされたストリームに対して非同期読み取り操作と同期読み取り操作を混在させることはできません。 のリダイレクトされたストリーム Process が非同期モードまたは同期モードで開かれると、そのストリームに対するそれ以降のすべての読み取り操作は同じモードである必要があります。 たとえば、ストリームでの のReadLineStandardOutput呼び出しに従BeginOutputReadLineわないでください。またはその逆も同様です。 ただし、異なるモードで 2 つの異なるストリームを読み取ることができます。 たとえば、ストリームを呼び出してから を呼び出 BeginOutputReadLineReadLineStandardError すことができます。

適用対象

こちらもご覧ください