Process.BeginOutputReadLine Process.BeginOutputReadLine Process.BeginOutputReadLine Process.BeginOutputReadLine Method

定義

アプリケーションのリダイレクトされた StandardOutput ストリームで、非同期読み取り操作を開始します。Begins asynchronous read operations on the redirected StandardOutput stream of the application.

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

例外

RedirectStandardOutput プロパティが false である。The RedirectStandardOutput property is false.

- または --or- StandardOutput ストリームで非同期読み取り操作は既に実行されています。An asynchronous read operation is already in progress on the StandardOutput stream.

または-or- StandardOutput ストリームは、同期読み取り操作によって使用されています。The StandardOutput stream has been used by a synchronous read operation.

次の例は、 StandardOutput sortコマンドのリダイレクトされたストリームで非同期の読み取り操作を実行する方法を示しています。The following example illustrates how to perform asynchronous read operations on the redirected StandardOutput stream of the sort command. sortコマンドは、テキスト入力の読み取りと並べ替えを行うコンソールアプリケーションです。The sort command is a console application that reads and sorts text input.

この例では、イベントハンドラーのSortOutputHandlerイベントデリゲートを作成し、イベントOutputDataReceivedに関連付けます。The example creates an event delegate for the SortOutputHandler event handler and associates it with the OutputDataReceived event. イベントハンドラーは、リダイレクトStandardOutputされたストリームからテキスト行を受け取り、テキストを書式設定して、画面にテキストを書き込みます。The event handler receives text lines from the redirected StandardOutput stream, formats the text, and writes the text to the screen.

// 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は、同期的または非同期的に読み取ることができます。The StandardOutput stream can be read synchronously or asynchronously. 、、などのメソッドは、プロセスの出力ストリームに対して同期読み取り操作を実行します。ReadToEnd ReadLine ReadMethods 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対して非同期の読み取り操作を実行するにProcessは、次の手順に従います。Follow these steps to perform asynchronous read operations on StandardOutput for a Process :

  1. UseShellExecutefalse に設定します。Set UseShellExecute to false.

  2. RedirectStandardOutputtrue に設定します。Set RedirectStandardOutput to true.

  3. イベントにイベントハンドラーをOutputDataReceived追加します。Add your event handler to the OutputDataReceived event. イベントハンドラーは、 System.Diagnostics.DataReceivedEventHandlerデリゲートシグネチャと一致している必要があります。The event handler must match the System.Diagnostics.DataReceivedEventHandler delegate signature.

  4. Process開始します。Start the Process.

  5. BeginOutputReadLineProcessを呼び出します。Call BeginOutputReadLine for the Process. この呼び出しは、で非同期読み取りStandardOutput操作を開始します。This call starts asynchronous read operations on StandardOutput.

非同期読み取り操作を開始すると、関連付けられているProcessStandardOutputストリームにテキスト行を書き込むたびに、イベントハンドラーが呼び出されます。When asynchronous read operations start, the event handler is called each time the associated Process writes a line of text to its StandardOutput stream.

を呼び出すCancelOutputReadことによって、非同期の読み取り操作を取り消すことができます。You can cancel an asynchronous read operation by calling CancelOutputRead. 読み取り操作は、呼び出し元またはイベントハンドラーによって取り消すことができます。The read operation can be canceled by the caller or by the event handler. をキャンセルした後、 BeginOutputReadLineを再度呼び出して、非同期の読み取り操作を再開できます。After canceling, you can call BeginOutputReadLine again to resume asynchronous read operations.

注意

リダイレクトされたストリームでは、非同期および同期読み取り操作を混在させることはできません。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 ストリームStandardOutputでをReadLine呼び出すことはできません。また、逆の場合も同様です。For example, do not follow BeginOutputReadLine with a call to ReadLine on the StandardOutput stream, or vice versa. ただし、異なるモードの2つの異なるストリームを読み取ることができます。However, you can read two different streams in different modes. たとえば、を呼び出しBeginOutputReadLineStandardErrorストリームに対して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.

適用対象

こちらもご覧ください