Process.BeginOutputReadLine Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Inizia le operazioni di lettura asincrona sul flusso StandardOutput reindirizzato dell'applicazione.
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 ()- Attributi
Eccezioni
La proprietà RedirectStandardOutput è false.
-oppure-
È già in corso un'operazione di lettura asincrona sul flusso StandardOutput.
-oppure-
Il flusso StandardOutput è stato usato da un'operazione di lettura sincrona.
Esempio
Nell'esempio seguente viene illustrato come eseguire operazioni di lettura asincrone nel flusso reindirizzato StandardOutput del sort comando . Il sort comando è un'applicazione console che legge e ordina l'input di testo.
L'esempio crea un delegato di evento per il SortOutputHandler gestore eventi e lo associa all'evento OutputDataReceived . Il gestore eventi riceve righe di testo dal flusso reindirizzato StandardOutput , formatta il testo e scrive il testo sullo schermo.
// 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
Commenti
Il StandardOutput flusso può essere letto in modo sincrono o asincrono. Metodi come Read, ReadLineed ReadToEnd eseguono operazioni di lettura sincrone nel flusso di output del processo. Queste operazioni di lettura sincrone non vengono completate fino a quando le scritture associate Process nel flusso StandardOutput non vengono completate o chiude il flusso.
Al contrario, BeginOutputReadLine avvia operazioni di lettura asincrone nel StandardOutput flusso. Questo metodo abilita un gestore eventi designato per l'output del flusso e torna immediatamente al chiamante, che può eseguire altre operazioni mentre l'output del flusso viene indirizzato al gestore eventi.
Seguire questa procedura per eseguire operazioni di lettura asincrone su StandardOutput per un Process oggetto :
Impostare UseShellExecute su
false.Impostare RedirectStandardOutput su
true.Aggiungere il gestore eventi all'evento OutputDataReceived . Il gestore eventi deve corrispondere alla firma del System.Diagnostics.DataReceivedEventHandler delegato.
Avviare il Process.
Chiamare BeginOutputReadLine per .Process Questa chiamata avvia operazioni di lettura asincrone su StandardOutput.
All'avvio delle operazioni di lettura asincrone, il gestore eventi viene chiamato ogni volta che l'oggetto associato Process scrive una riga di testo nel flusso StandardOutput .
È possibile annullare un'operazione di lettura asincrona chiamando CancelOutputRead. L'operazione di lettura può essere annullata dal chiamante o dal gestore eventi. Dopo l'annullamento, è possibile chiamare BeginOutputReadLine di nuovo per riprendere le operazioni di lettura asincrone.
Nota
Non è possibile combinare operazioni di lettura asincrone e sincrone in un flusso reindirizzato. Dopo l'apertura del flusso reindirizzato di un Process oggetto in modalità asincrona o sincrona, tutte le altre operazioni di lettura su tale flusso devono trovarsi nella stessa modalità. Ad esempio, non seguire BeginOutputReadLine con una chiamata a ReadLine sul StandardOutput flusso o viceversa. Tuttavia, è possibile leggere due flussi diversi in modalità diverse. Ad esempio, è possibile chiamare e quindi chiamare BeginOutputReadLineReadLine per il StandardError flusso.
