Process.BeginOutputReadLine Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Inicia as operações de leitura assíncronas no fluxo StandardOutput redirecionado do aplicativo.
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 -> unitPublic Sub BeginOutputReadLine ()- Atributos
Exceções
A propriedade RedirectStandardOutput é false.
- ou -
Uma operação de leitura assíncrona já está em andamento no fluxo StandardOutput.
- ou -
O fluxo StandardOutput foi usado por uma operação de leitura síncrona.
Exemplos
O exemplo a seguir ilustra como executar operações de leitura assíncronas no fluxo redirecionado StandardOutput do sort comando. O sort comando é um aplicativo de console que lê e classifica a entrada de texto.
O exemplo cria um delegado de evento para o manipulador de eventos e o SortOutputHandler associa ao OutputDataReceived evento . O manipulador de eventos recebe linhas de texto do fluxo redirecionado StandardOutput , formata o texto e grava o texto na tela.
// 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
Comentários
O StandardOutput fluxo pode ser lido de forma síncrona ou assíncrona. Métodos como Read, ReadLinee ReadToEnd executam operações de leitura síncronas no fluxo de saída do processo. Essas operações de leitura síncronas não são concluídas até que o associado Process grave em seu StandardOutput fluxo ou feche o fluxo.
Por outro lado, BeginOutputReadLine inicia operações de leitura assíncronas no StandardOutput fluxo. Esse método habilita um manipulador de eventos designado para a saída do fluxo e retorna imediatamente ao chamador, que pode executar outro trabalho enquanto a saída do fluxo é direcionada para o manipulador de eventos.
Siga estas etapas para executar operações de leitura assíncronas em StandardOutput para um Process :
Defina UseShellExecute como
false.Defina RedirectStandardOutput como
true.Adicione o manipulador de eventos ao OutputDataReceived evento. O manipulador de eventos deve corresponder à System.Diagnostics.DataReceivedEventHandler assinatura delegada.
Inicie o Process.
Chame BeginOutputReadLine para o Process. Essa chamada inicia operações de leitura assíncronas em StandardOutput.
Quando as operações de leitura assíncronas são iniciadas, o manipulador de eventos é chamado sempre que o associado Process grava uma linha de texto em seu StandardOutput fluxo.
Você pode cancelar uma operação de leitura assíncrona chamando CancelOutputRead. A operação de leitura pode ser cancelada pelo chamador ou pelo manipulador de eventos. Depois de cancelar, você pode chamar BeginOutputReadLine novamente para retomar operações de leitura assíncronas.
Observação
Não é possível misturar operações de leitura assíncronas e síncronas em um fluxo redirecionado. Depois que o fluxo redirecionado de um Process for aberto no modo assíncrono ou síncrono, todas as operações de leitura adicionais nesse fluxo deverão estar no mesmo modo. Por exemplo, não siga BeginOutputReadLine com uma chamada para ReadLine no StandardOutput fluxo ou vice-versa. No entanto, você pode ler dois fluxos diferentes em modos diferentes. Por exemplo, você pode chamar BeginOutputReadLine e chamar ReadLine para o StandardError fluxo.
