Process.BeginOutputReadLine Metode

Definisi

Ruang nama:

System.Diagnostics

Rakitan:

netstandard.dll, System.Diagnostics.Process.dll

Sumber:

Process.cs

Memulai operasi baca asinkron pada aliran StandardOutput aplikasi yang dialihkan.

public:
 void BeginOutputReadLine();

public void BeginOutputReadLine();

member this.BeginOutputReadLine : unit -> unit

Public Sub BeginOutputReadLine ()

Pengecualian

InvalidOperationException

Properti RedirectStandardOutput adalah false.

-atau-

Operasi baca asinkron sudah berlangsung pada StandardOutput aliran.

-atau-

Aliran StandardOutput telah digunakan oleh operasi baca sinkron.

Contoh

Contoh berikut mengilustrasikan cara melakukan operasi baca asinkron pada aliran perintah yang StandardOutput dialihkansort. Perintah sort adalah aplikasi konsol yang membaca dan mengurutkan input teks.

Contoh membuat delegasi peristiwa untuk SortOutputHandler penanganan aktivitas dan mengaitkannya dengan OutputDataReceived peristiwa. Penanganan aktivitas menerima baris teks dari aliran yang dialihkan StandardOutput , memformat teks, dan menulis teks ke layar.

// 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

Keterangan

Aliran StandardOutput dapat dibaca secara sinkron atau asinkron. Metode seperti Read, ReadLine, dan ReadToEnd melakukan operasi baca sinkron pada aliran output proses. Operasi baca sinkron ini tidak selesai sampai penulisan terkait Process ke alirannya StandardOutput , atau menutup aliran.

Sebaliknya, BeginOutputReadLine memulai operasi baca asinkron pada StandardOutput aliran. Metode ini memungkinkan penanganan aktivitas yang ditunjuk untuk output aliran dan segera kembali ke pemanggil, yang dapat melakukan pekerjaan lain saat output aliran diarahkan ke penanganan aktivitas.

Ikuti langkah-langkah ini untuk melakukan operasi baca asinkron pada StandardOutput untuk Process :

1. Atur UseShellExecute ke false.

2. Atur RedirectStandardOutput ke true.

3. Tambahkan penanganan aktivitas Anda ke OutputDataReceived peristiwa. Penanganan aktivitas harus cocok dengan System.Diagnostics.DataReceivedEventHandler tanda tangan delegasi.

4. Mulai Process.

5. Panggil BeginOutputReadLine untuk Process. Panggilan ini memulai operasi baca asinkron pada StandardOutput.

Ketika operasi baca asinkron dimulai, penanganan aktivitas dipanggil setiap kali yang terkait Process menulis baris teks ke alirannya StandardOutput .

Anda dapat membatalkan operasi baca asinkron dengan memanggil CancelOutputRead. Operasi baca dapat dibatalkan oleh pemanggil atau oleh penanganan aktivitas. Setelah membatalkan, Anda dapat memanggil BeginOutputReadLine lagi untuk melanjutkan operasi baca asinkron.

Note

Anda tidak dapat mencampur operasi baca asinkron dan sinkron pada aliran yang dialihkan. Setelah aliran Process yang dialihkan dibuka dalam mode asinkron atau sinkron, semua operasi baca lebih lanjut pada aliran tersebut harus dalam mode yang sama. Misalnya, jangan ikuti BeginOutputReadLine dengan panggilan ke ReadLineStandardOutput di stream, atau sebaliknya. Namun, Anda dapat membaca dua aliran yang berbeda dalam mode yang berbeda. Misalnya, Anda dapat memanggil BeginOutputReadLine lalu memanggil ReadLineStandardError aliran.

Lihat juga

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