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.BeginErrorReadLine (Método)

Inicia las operaciones de lectura asincrónica en la secuencia de StandardError redirigida de la aplicación.

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

[ComVisibleAttribute(false)]
public void BeginErrorReadLine()

ExcepciónCondición
InvalidOperationException

La propiedad ProcessStartInfo.RedirectStandardError es false.

‑O bien-

Ya hay una operación de lectura asincrónica en curso en la secuencia de StandardError.

‑O bien-

Una operación de lectura sincrónica ha utilizado la secuencia de StandardError.

La secuencia de StandardError puede leerse de manera sincrónica o asincrónica. Los métodos como Read, ReadLine y ReadToEnd realizan operaciones de lectura sincrónica en el flujo de salida de error del proceso. Estas operaciones de lectura sincrónica no terminan hasta que el Process asociado escribe en la secuencia de StandardError o cierra la secuencia.

Por contraste, BeginErrorReadLine inicia las operaciones de lectura asincrónica en la secuencia de StandardError. Este método habilita el controlador de eventos designado para los resultados de la secuencia y vuelve inmediatamente al llamador, que puede realizar otro trabajo mientras los resultados de la secuencia se dirigen al controlador de eventos.

Siga estos pasos para realizar operaciones de lectura asincrónica en StandardError para un Process:

  1. Establezca UseShellExecute en false.

  2. Establezca RedirectStandardError en true.

  3. Agregue el controlador de eventos al evento ErrorDataReceived. El controlador de eventos debe coincidir con la firma de delegado de System.Diagnostics.DataReceivedEventHandler.

  4. Inicie Process.

  5. Llame a BeginErrorReadLine para el Process. Esta llamada inicia las operaciones de lectura asincrónica en StandardError.

Cuando se inician las operaciones de lectura asincrónica, se llama al controlador de eventos cada vez que el Process asociado escribe una línea de texto en su secuencia de StandardError.

Las operaciones de lectura asincrónica se pueden cancelar llamando a CancelErrorRead. El llamador o el controlador de eventos puede cancelar las operaciones de lectura. Después de cancelar, se puede volver a llamar a BeginErrorReadLine para reanudar las operaciones de lectura asincrónica.

NotaNota

No se pueden mezclar las operaciones de lectura asincrónica y las de lectura sincrónica en una secuencia redirigida. 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. Por ejemplo, después de BeginErrorReadLine no llame a ReadLine en la secuencia de StandardError o viceversa. Sin embargo, se pueden leer dos secuencias diferentes en modos diferentes. Por ejemplo, se puede llamar a BeginErrorReadLine y, a continuación, llamar a ReadLine para la secuencia de StandardOutput.

En el ejemplo siguiente se utiliza el comando net view para mostrar los recursos de red disponibles en un equipo remoto. El usuario proporciona el nombre del equipo de destino como un argumento de la línea de comandos. El usuario también puede proporcionar un nombre de archivo para la salida de errores. En el ejemplo se recopilan los resultados del comando de red, se espera a que termine el proceso y, a continuación, se escriben los resultados en la consola. Si el usuario proporciona el archivo de errores opcional, se escriben en el ejemplo los errores en dicho archivo.


// Define the namespaces used by this sample.
using System;
using System.Text;
using System.Globalization;
using System.IO;
using System.Diagnostics;
using System.Threading;
using System.ComponentModel;


namespace ProcessAsyncStreamSamples
{

    class ProcessNetStreamRedirection
    {
        // Define static variables shared by class methods.
        private static StreamWriter streamError =null;
        private static String netErrorFile = "";
        private static StringBuilder netOutput = null;
        private static bool errorRedirect = false;
        private static bool errorsWritten = false;

        public static void RedirectNetCommandStreams()
        {
            String netArguments;
            Process netProcess;

            // Get the input computer name.
            Console.WriteLine("Enter the computer name for the net view command:");
            netArguments = Console.ReadLine().ToUpper(CultureInfo.InvariantCulture);
            if (String.IsNullOrEmpty(netArguments))
            {
                // Default to the help command if there is not an input argument.
                netArguments = "/?";
            }

            // Check if errors should be redirected to a file.
            errorsWritten = false;
            Console.WriteLine("Enter a fully qualified path to an error log file");
            Console.WriteLine("  or just press Enter to write errors to console:");
            netErrorFile = Console.ReadLine().ToUpper(CultureInfo.InvariantCulture);
            if (!String.IsNullOrEmpty(netErrorFile))
            {
                errorRedirect = true;
            }

            // Note that at this point, netArguments and netErrorFile
            // are set with user input.  If the user did not specify
            // an error file, then errorRedirect is set to false.

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

            // Build the net command argument list.
            netProcess.StartInfo.Arguments = String.Format("view {0}", 
                netArguments);

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

            // Redirect the standard output of the net command.  
            // This stream is read asynchronously using an event handler.
            netProcess.StartInfo.RedirectStandardOutput = true;
            netProcess.OutputDataReceived += new DataReceivedEventHandler(NetOutputDataHandler);
            netOutput = new StringBuilder();

            if (errorRedirect)
            {
                // Redirect the error output of the net command. 
                netProcess.StartInfo.RedirectStandardError = true;
                netProcess.ErrorDataReceived += new DataReceivedEventHandler(NetErrorDataHandler);
            }
            else 
            {
                // Do not redirect the error output.
                netProcess.StartInfo.RedirectStandardError = false;
            }

            Console.WriteLine("\nStarting process: net {0}", 
                netProcess.StartInfo.Arguments);
            if (errorRedirect)
            {
                Console.WriteLine("Errors will be written to the file {0}", 
                    netErrorFile);
            }

            // Start the process.
            netProcess.Start();

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

            if (errorRedirect)
            {
                // Start the asynchronous read of the standard
                // error stream.
                netProcess.BeginErrorReadLine();
            }

            // Let the net command run, collecting the output.
            netProcess.WaitForExit();

            if (streamError != null)
            {
                // Close the error file.
                streamError.Close();
            }
            else 
            {
                // Set errorsWritten to false if the stream is not
                // open.   Either there are no errors, or the error
                // file could not be opened.
                errorsWritten = false;
            }

            if (netOutput.Length > 0)
            {
                // If the process wrote more than just
                // white space, write the output to the console.
                Console.WriteLine("\nPublic network shares from net view:\n{0}\n", 
                    netOutput);
            }

            if (errorsWritten)
            {
                // Signal that the error file had something 
                // written to it.
                String [] errorOutput = File.ReadAllLines(netErrorFile);
                if (errorOutput.Length > 0)
                {
                    Console.WriteLine("\nThe following error output was appended to {0}.",
                        netErrorFile);
                    foreach (String errLine in errorOutput)
                    {
                        Console.WriteLine("  {0}", errLine);
                    }
                }
                Console.WriteLine();
            }

            netProcess.Close();

        }

        private static void NetOutputDataHandler(object sendingProcess, 
            DataReceivedEventArgs outLine)
        {
            // Collect the net view command output.
            if (!String.IsNullOrEmpty(outLine.Data))
            {
                // Add the text to the collected output.
                netOutput.Append(Environment.NewLine + "  " + outLine.Data);
            }
        }

        private static void NetErrorDataHandler(object sendingProcess, 
            DataReceivedEventArgs errLine)
        {
            // Write the error text to the file if there is something
            // to write and an error file has been specified.

            if (!String.IsNullOrEmpty(errLine.Data))
            {
                if (!errorsWritten)
                {
                    if (streamError == null)
                    {
                        // Open the file.
                        try 
                        {
                            streamError = new StreamWriter(netErrorFile, true);
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine("Could not open error file!");
                            Console.WriteLine(e.Message.ToString());
                        }
                    }

                    if (streamError != null)
                    {
                        // Write a header to the file if this is the first
                        // call to the error output handler.
                        streamError.WriteLine();
                        streamError.WriteLine(DateTime.Now.ToString());
                        streamError.WriteLine("Net View error output:");
                    }
                    errorsWritten = true;
                }

                if (streamError != null)
                {
                    // Write redirected errors to the file.
                    streamError.WriteLine(errLine.Data);
                    streamError.Flush();
                }
            }
        }
    }
} 


.NET Framework

Compatible con: 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

  • 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