Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original.
Traducción
Original

Process.CancelOutputRead (Método)

Cancela la operación de lectura asincrónica en la secuencia redirigida de StandardOutput de una aplicación.

Espacio de nombres:  System.Diagnostics
Ensamblado:  System (en System.dll)

[ComVisibleAttribute(false)]
public void CancelOutputRead()

ExcepciónCondición
InvalidOperationException

La secuencia de StandardOutput no está habilitada para las operaciones de lectura asincrónica.

BeginOutputReadLine inicia una operación de lectura asincrónica en la secuencia StandardOutput. CancelOutputRead finaliza una operación de lectura asincrónica.

Después de cancelar, se pueden reanudar las operaciones de lectura asincrónica llamando de nuevo a BeginOutputReadLine.

Cuando se llama a CancelOutputRead, finalizan todas las operaciones de lectura en curso para StandardOutput y, a continuación, se deshabilita el controlador de eventos. Todos los resultados redirigidos adicionales de StandardOutput se guardan en un búfer. Si se vuelve a habilitar el controlador de eventos con una llamada a BeginOutputReadLine, se envían los resultados guardados al controlador de eventos y se reanudan las operaciones de lectura asincrónica. Si desea cambiar el controlador de eventos antes de continuar con las operaciones de lectura asincrónica, deberá quitar el controlador de eventos existente antes de agregar el nuevo controlador de eventos:

    // At this point the DataReceivedEventHandler(OutputHandler1) 
    // has executed a CancelOutputRead.

    // Remove the prior event handler.
    process.OutputDataReceived -= 
        new DataReceivedEventHandler(OutputHandler1);

    // Register a new event handler.
    process.OutputDataReceived += 
        new DataReceivedEventHandler(OutputHandler2);

    // Call the corresponding BeginOutputReadLine.
    process.BeginOutputReadLine();
NotaNota

No se pueden mezclar las operaciones de lectura asincrónica y las de lectura sincrónica en la secuencia redirigida de StandardOutput. Cuando se abre la secuencia redirigida de un Process en modo asincrónico o sincrónico, todas las operaciones de lectura adicionales en esa secuencia deben estar en el mismo modo. Si se cancela una operación de lectura asincrónica en StandardOutput y, a continuación, se necesita leer de nuevo la secuencia, se debe utilizar BeginOutputReadLine para reanudar las operaciones de lectura asincrónica. Después de CancelOutputRead, no llame a los métodos de lectura sincrónica de StandardOutput como Read, ReadLine o ReadToEnd.

En el ejemplo siguiente se inicia el comando nmake con argumentos proporcionados por el usuario. Los flujos de error y de salida se leen de forma asincrónica; las líneas de texto recopiladas se muestran en la consola y se escriben en un archivo de registro. Si el resultado del comando sobrepasa un número especificado de líneas, se cancelan las operaciones de lectura asincrónica.


namespace ProcessAsyncStreamSamples
{
    class ProcessNMakeStreamRedirection
    {
        // Define static variables shared by class methods.
        private static StreamWriter buildLogStream =null;
        private static Mutex logMutex = new Mutex();
        private static int maxLogLines = 25;
        private static int currentLogLines = 0;

        public static void RedirectNMakeCommandStreams()
        {
            String nmakeArguments = null;
            Process nmakeProcess;

            // Get the input nmake command-line arguments.
            Console.WriteLine("Enter the NMake command line arguments " +
                "(@commandfile or /f makefile, etc):");
            String inputText = Console.ReadLine();
            if (!String.IsNullOrEmpty(inputText))
            {
                nmakeArguments = inputText;
            }

            Console.WriteLine("Enter max line limit for log file (default is 25):");
            inputText = Console.ReadLine();
            if (!String.IsNullOrEmpty(inputText))
            {
                if (!Int32.TryParse(inputText, out maxLogLines))
                {
                    maxLogLines = 25;
                }
            }
            Console.WriteLine("Output beyond {0} lines will be ignored.",
                maxLogLines);

            // Initialize the process and its StartInfo properties.
            nmakeProcess = new Process();
            nmakeProcess.StartInfo.FileName = "NMake.exe";

            // Build the nmake command argument list.
            if (!String.IsNullOrEmpty(nmakeArguments))
            {
                nmakeProcess.StartInfo.Arguments = nmakeArguments;
            }

            // Set UseShellExecute to false for redirection.
            nmakeProcess.StartInfo.UseShellExecute = false;

            // Redirect the standard output of the nmake command.  
            // Read the stream asynchronously using an event handler.
            nmakeProcess.StartInfo.RedirectStandardOutput = true;
            nmakeProcess.OutputDataReceived += new DataReceivedEventHandler(NMakeOutputDataHandler);

            // Redirect the error output of the nmake command. 
            nmakeProcess.StartInfo.RedirectStandardError = true;
            nmakeProcess.ErrorDataReceived += new DataReceivedEventHandler(NMakeErrorDataHandler);

            logMutex.WaitOne();

            currentLogLines = 0;

            // Write a header to the log file.
            const String buildLogFile = "NmakeCmd.Txt";
            try 
            {
                buildLogStream = new StreamWriter(buildLogFile, true);
            }
            catch (Exception e)
            {
                Console.WriteLine("Could not open output file {0}", buildLogFile);
                Console.WriteLine("Exception = {0}", e.ToString());
                Console.WriteLine(e.Message);

                buildLogStream = null;
            }

            if (buildLogStream != null)
            {   
                Console.WriteLine("Nmake output logged to {0}", 
                    buildLogFile);

                buildLogStream.WriteLine();
                buildLogStream.WriteLine(DateTime.Now.ToString());
                if (!String.IsNullOrEmpty(nmakeArguments))
                {
                    buildLogStream.Write("Command line = NMake {0}",
                        nmakeArguments);
                }
                else 
                {
                    buildLogStream.Write("Command line = Nmake");
                }
                buildLogStream.WriteLine();
                buildLogStream.Flush();

                logMutex.ReleaseMutex();

                // Start the process.
                Console.WriteLine();
                Console.WriteLine("\nStarting Nmake command...");
                Console.WriteLine();
                nmakeProcess.Start();

                // Start the asynchronous read of the error stream.
                nmakeProcess.BeginErrorReadLine();

                // Start the asynchronous read of the output stream.
                nmakeProcess.BeginOutputReadLine();

                // Let the nmake command run, collecting the output.
                nmakeProcess.WaitForExit();

                nmakeProcess.Close();
                buildLogStream.Close();
            }
        }

        private static void NMakeOutputDataHandler(object sendingProcess, 
            DataReceivedEventArgs outLine)
        {
            // Collect the output, displaying it to the screen and 
            // logging it to the output file.  Cancel the read
            // operation when the maximum line limit is reached.

            if (!String.IsNullOrEmpty(outLine.Data))
            {
                logMutex.WaitOne();

                currentLogLines++;
                if (currentLogLines > maxLogLines)
                {
                    // Display the line to the console.
                    // Skip writing the line to the log file.
                    Console.WriteLine("StdOut: {0}", outLine.Data);
                }
                else if (currentLogLines == maxLogLines)
                {
                    LogToFile("StdOut", "<Max build log limit reached!>", 
                        true);

                    // Stop reading the output streams.
                    Process p = sendingProcess as Process;
                    if (p != null)
                    {
                        p.CancelOutputRead();
                        p.CancelErrorRead();
                    }
                }
                else 
                {
                    // Write the line to the log file.
                    LogToFile("StdOut", outLine.Data, true);
                }
                logMutex.ReleaseMutex();
            }
        }

        private static void NMakeErrorDataHandler(object sendingProcess, 
            DataReceivedEventArgs errLine)
        {
            // Collect error output, displaying it to the screen and 
            // logging it to the output file.  Cancel the error output
            // read operation when the maximum line limit is reached.

            if (!String.IsNullOrEmpty(errLine.Data))
            {
                logMutex.WaitOne();

                currentLogLines++;
                if (currentLogLines > maxLogLines)
                {
                    // Display the error line to the console.
                    // Skip writing the line to the log file.
                    Console.WriteLine("StdErr: {0}", errLine.Data);
                }
                else if (currentLogLines == maxLogLines)
                {
                    LogToFile("StdErr", "<Max build log limit reached!>", 
                        true);

                    // Stop reading the output streams
                    Process p = sendingProcess as Process;
                    if (p != null)
                    {
                        p.CancelErrorRead();
                        p.CancelOutputRead();

                    }
                }
                else 
                {
                    // Write the line to the log file.
                    LogToFile("StdErr", errLine.Data, true);
                }

                logMutex.ReleaseMutex();
            }
        }

        private static void LogToFile(String logPrefix, 
            String logText, bool echoToConsole)
        {
            // Write the specified line to the log file stream.
            StringBuilder logString = new StringBuilder();

            if (!String.IsNullOrEmpty(logPrefix))
            {
                logString.AppendFormat("{0}> ", logPrefix);
            }

            if (!String.IsNullOrEmpty(logText))
            {
                logString.Append(logText); 
            }

            if (buildLogStream != null)
            {
                buildLogStream.WriteLine("[{0}] {1}",
                    DateTime.Now.ToString(), logString.ToString());
                buildLogStream.Flush();
            }

            if (echoToConsole)
            {
                Console.WriteLine(logString.ToString());
            }
        }
    }
} 


.NET Framework

Compatible con: 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

  • SecurityAction.LinkDemand 

    para plena confianza del llamador inmediato. Este miembro no puede ser utilizado por código de confianza parcial.

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft