DataReceivedEventHandler Delegado

Definición

Espacio de nombres:

System.Diagnostics

Ensamblado:

System.Diagnostics.Process.dll

Representa el método que controlará los eventos OutputDataReceived o ErrorDataReceived de un Process.

C#

public delegate void DataReceivedEventHandler(object sender, DataReceivedEventArgs e);

Parámetros

sender

Object

Origen del evento.

e

DataReceivedEventArgs

Objeto DataReceivedEventArgs que contiene los datos del evento.

Ejemplos

En el ejemplo de código siguiente se muestra cómo realizar operaciones de lectura asincrónicas en el flujo redirigido StandardOutput del comando sort . El comando sort es una aplicación de consola que lee y ordena la entrada de texto.

En el ejemplo se crea un DataReceivedEventHandler delegado para el SortOutputHandler controlador de eventos y se asocia el delegado con el OutputDataReceived evento . El controlador de eventos recibe líneas de texto de la secuencia redirigida StandardOutput , da formato al texto y escribe el texto en la pantalla.

C#

// 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);
            }
        }
    }
}

Comentarios

Cuando se crea un delegado DataReceivedEventHandler, se identifica el método que controlará el evento. Para asociar el evento al controlador, se debe agregar una instancia del delegado al evento. Siempre que se produce el evento, se llama a su controlador, a menos que se quite el delegado. Para obtener más información sobre los delegados del controlador de eventos, consulte Control y generación de eventos.

Para recopilar de forma asincrónica la salida redirigida StandardOutput o StandardError de flujo de un proceso, agregue el controlador de eventos al OutputDataReceived evento o ErrorDataReceived . Estos eventos se generan cada vez que el proceso escribe una línea en la secuencia redirigida correspondiente. Cuando se cierra el flujo redirigido, se envía una línea NULA al controlador de eventos. Asegúrese de que el controlador de eventos comprueba esta condición antes de acceder a la Data propiedad . Por ejemplo, puede usar el static método String.IsNullOrEmpty para validar la propiedad en el Data controlador de eventos.

Métodos de extensión

GetMethodInfo(Delegate)

Obtiene un objeto que representa el método representado por el delegado especificado.

Se aplica a

Consulte también

• DataReceivedEventArgs
• OutputDataReceived
• ErrorDataReceived
• Process