Process.BeginOutputReadLine メソッド

public:
 void BeginOutputReadLine();

[System.Runtime.InteropServices.ComVisible(false)]
public void BeginOutputReadLine();

public void BeginOutputReadLine();

[<System.Runtime.InteropServices.ComVisible(false)>]
member this.BeginOutputReadLine : unit -> unit

member this.BeginOutputReadLine : unit -> unit

Public Sub BeginOutputReadLine ()

属性

ComVisibleAttribute

例外

例

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

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

// 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.
open System
open System.Text
open System.Diagnostics

// Define variables shared by class methods.
let mutable sortOutput = StringBuilder()
let mutable numOutputLines = 0;

let sortOutputHandler (sendingProcess: obj) (outLine: DataReceivedEventArgs) =
    // Collect the sort command output.
    if String.IsNullOrEmpty outLine.Data |> not then
        numOutputLines <- numOutputLines + 1
        // Add the text to the collected output.
        sortOutput.Append(Environment.NewLine + $"[{numOutputLines}] - {outLine.Data}") |> ignore

let sortInputListText () =
    // Initialize the process and its StartInfo properties.
    // The sort command is a console application that
    // reads and sorts text input.

    let 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 <- StringBuilder();

    // Set our event handler to asynchronously read the sort output.
    sortProcess.OutputDataReceived.AddHandler sortOutputHandler

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

    // Start the process.
    sortProcess.Start() |> ignore

    // Use a stream writer to synchronously write the sort input.
    let 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.
    printfn "Ready to sort up to 50 lines of text"

    let mutable inputText = ""
    let mutable numInputLines = 0
    while String.IsNullOrEmpty inputText do
        printfn "Enter a text line (or press the Enter key to stop):"

        inputText <- Console.ReadLine()
        if String.IsNullOrEmpty inputText |> not then
            numInputLines <- numInputLines + 1
            sortStreamWriter.WriteLine inputText

    printfn "<end of input stream>\n"

    // 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 then
        // Write the formatted and sorted output to the console.
        printfn $" Sort results = {numOutputLines} sorted text line(s) "
        printfn "----------"
        printfn $"{sortOutput}"
    else
        printfn " No input lines were sorted."

    sortProcess.Close();

// The main entry point for the application.
do
    try
        sortInputListText ()
    with :? InvalidOperationException as e ->
        printfn "Exception:"
        printfn $"{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 ストリームは、同期的または非同期的に読み取ることができます。 Read、ReadLine、ReadToEndなどのメソッドは、プロセスの出力ストリームに対して同期読み取り操作を実行します。 これらの同期読み取り操作は、関連付けられている Process が StandardOutput ストリームに書き込むか、ストリームを閉じるまで完了しません。

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

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

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

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

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

4. Process を開始します。

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

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

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

こちらもご覧ください

• RedirectStandardOutput
• StandardOutput
• OutputDataReceived
• DataReceivedEventHandler
• CancelOutputRead()