Process.BeginErrorReadLine Метод

Определение

Начинает операции асинхронного чтения с перенаправленного потока StandardError приложения.

public:
 void BeginErrorReadLine();
public void BeginErrorReadLine ();
[System.Runtime.InteropServices.ComVisible(false)]
public void BeginErrorReadLine ();
member this.BeginErrorReadLine : unit -> unit
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.BeginErrorReadLine : unit -> unit
Public Sub BeginErrorReadLine ()
Атрибуты

Исключения

Значение свойства RedirectStandardErrorfalse.

-или- Асинхронная операция чтения уже выполняется в потоке StandardError.

-или- Поток StandardError используется синхронной операцией чтения.

Примеры

В следующем примере команда используется net view для вывода списка доступных сетевых ресурсов на удаленном компьютере. Пользователь предоставляет имя целевого компьютера в качестве аргумента командной строки. Пользователь также может указать имя файла для вывода ошибок. В примере выполняется сбор выходных данных команды NET, ожидание завершения процесса и запись выходных результатов в консоль. Если пользователь предоставляет необязательный файл ошибок, в примере в файл записываются ошибки.

// Define the namespaces used by this sample.
#using <System.dll>

using namespace System;
using namespace System::Text;
using namespace System::Globalization;
using namespace System::IO;
using namespace System::Diagnostics;
using namespace System::Threading;
using namespace System::ComponentModel;

ref class ProcessNetStreamRedirection
{
private:
   // Define static variables shared by class methods.
   static StreamWriter^ streamError = nullptr;
   static String^ netErrorFile = "";
   static StringBuilder^ netOutput = nullptr;
   static bool errorRedirect = false;
   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 = gcnew 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 += gcnew DataReceivedEventHandler( NetOutputDataHandler );
      netOutput = gcnew StringBuilder;
      if ( errorRedirect )
      {
         
         // Redirect the error output of the net command. 
         netProcess->StartInfo->RedirectStandardError = true;
         netProcess->ErrorDataReceived += gcnew 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 != nullptr )
      {
         // 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->ToString() );
      }

      if ( errorsWritten )
      {
         // Signal that the error file had something 
         // written to it.
         array<String^>^errorOutput = File::ReadAllLines( netErrorFile );
         if ( errorOutput->Length > 0 )
         {
            Console::WriteLine( "\nThe following error output was appended to {0}.",
               netErrorFile );
            System::Collections::IEnumerator^ myEnum = errorOutput->GetEnumerator();
            while ( myEnum->MoveNext() )
            {
               String^ errLine = safe_cast<String^>(myEnum->Current);
               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->AppendFormat(  "\n  {0}", outLine->Data );
      }
   }

   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 == nullptr )
            {
               // Open the file.
               try
               {
                  streamError = gcnew StreamWriter( netErrorFile,true );
               }
               catch ( Exception^ e ) 
               {
                  Console::WriteLine(  "Could not open error file!" );
                  Console::WriteLine( e->Message->ToString() );
               }
            }

            if ( streamError != nullptr )
            {
               // 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 != nullptr )
         {
            // Write redirected errors to the file.
            streamError->WriteLine( errLine->Data );
            streamError->Flush();
         }
      }
   }
};
// 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();
                }
            }
        }
    }
}
' Define the namespaces used by this sample.
Imports System.Text
Imports System.Globalization
Imports System.IO
Imports System.Diagnostics
Imports System.Threading
Imports System.ComponentModel

Namespace ProcessAsyncStreamSamples
   
   Class ProcessAsyncErrorRedirection
      ' Define static variables shared by class methods.
      Private Shared streamError As StreamWriter = Nothing
      Private Shared netErrorFile As String = ""
      Private Shared netOutput As StringBuilder = Nothing
      Private Shared errorRedirect As Boolean = False
      Private Shared errorsWritten As Boolean = False
      
      Public Shared Sub RedirectNetCommandStreams()
         Dim netArguments As String
         Dim netProcess As Process
         
         ' 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) Then
            ' Default to the help command if there is 
            ' not an input argument.
            netArguments = "/?"
         End If
         
         ' 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 Not String.IsNullOrEmpty(netErrorFile) Then
            errorRedirect = True
         End If
         
         ' 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.  
         ' Read the stream asynchronously using an event handler.
         netProcess.StartInfo.RedirectStandardOutput = True
         AddHandler netProcess.OutputDataReceived, _
                            AddressOf NetOutputDataHandler
         netOutput = new StringBuilder()
         
         If errorRedirect Then
            ' Redirect the error output of the net command. 
            netProcess.StartInfo.RedirectStandardError = True
            AddHandler netProcess.ErrorDataReceived, _
                            AddressOf NetErrorDataHandler
         Else
            ' Do not redirect the error output.
            netProcess.StartInfo.RedirectStandardError = False
         End If
         
         Console.WriteLine(ControlChars.Lf + "Starting process: NET {0}", _
                           netProcess.StartInfo.Arguments)
         If errorRedirect Then
            Console.WriteLine("Errors will be written to the file {0}", _
                           netErrorFile)
         End If
         
         ' Start the process.
         netProcess.Start()
         
         ' Start the asynchronous read of the standard output stream.
         netProcess.BeginOutputReadLine()
         
         If errorRedirect Then
            ' Start the asynchronous read of the standard
            ' error stream.
            netProcess.BeginErrorReadLine()
         End If
         
         ' Let the net command run, collecting the output.
         netProcess.WaitForExit()
      
         If Not streamError Is Nothing Then
             ' 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
         End If
   
         If netOutput.Length > 0 Then
            ' If the process wrote more than just
            ' white space, write the output to the console.
            Console.WriteLine()
            Console.WriteLine("Public network shares from net view:")
            Console.WriteLine()
            Console.WriteLine(netOutput)
            Console.WriteLine()
         End If
         
         If errorsWritten Then
            ' Signal that the error file had something 
            ' written to it.
            Dim errorOutput As String()
            errorOutput = File.ReadAllLines(netErrorFile)
            If errorOutput.Length > 0 Then

                Console.WriteLine(ControlChars.Lf + _
                    "The following error output was appended to {0}.", _
                    netErrorFile)
                Dim errLine as String
                For Each errLine in errorOutput
                    Console.WriteLine("  {0}", errLine)
                Next
          
                Console.WriteLine()
            End If
         End If
         
         netProcess.Close()
      End Sub 
      
      
      Private Shared Sub NetOutputDataHandler(sendingProcess As Object, _
          outLine As DataReceivedEventArgs)

         ' Collect the net view command output.
         If Not String.IsNullOrEmpty(outLine.Data) Then
            ' Add the text to the collected output.
            netOutput.Append(Environment.NewLine + "  " + outLine.Data)
         End If
      End Sub 
       
      
      Private Shared Sub NetErrorDataHandler(sendingProcess As Object, _
          errLine As DataReceivedEventArgs)

         ' Write the error text to the file if there is something to
         ' write and an error file has been specified.

         If Not String.IsNullOrEmpty(errLine.Data) Then

            If Not errorsWritten Then
                If streamError Is Nothing Then
                    ' Open the file.
                    Try 
                        streamError = New StreamWriter(netErrorFile, true)
                    Catch e As Exception
                        Console.WriteLine("Could not open error file!")
                        Console.WriteLine(e.Message.ToString())
                    End Try
                End If

                If Not streamError Is Nothing Then

                    ' 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:")

                End If

                errorsWritten = True
            End If
                     
            If Not streamError Is Nothing Then
                  
                ' Write redirected errors to the file.
                streamError.WriteLine(errLine.Data)
                streamError.Flush()
             End If
          End If
      End Sub 
   End Class  
End Namespace

Комментарии

StandardErrorПоток может считываться синхронно или асинхронно. Такие методы Read , как, ReadLine и ReadToEnd выполняют синхронные операции чтения для потока вывода ошибок процесса. Эти операции синхронного чтения не завершаются до тех пор, пока не будут вызваны связанные операции Process записи в свой StandardError поток или закрывается поток.

В отличие от этого, BeginErrorReadLine запускает асинхронные операции чтения в StandardError потоке. Этот метод включает назначенный обработчик событий для выходного потока и сразу же возвращает вызывающему объекту, который может выполнять другие действия, пока выходные данные потока направляются в обработчик событий.

Выполните следующие действия для выполнения асинхронных операций чтения StandardError для Process :

  1. Задайте для параметра UseShellExecute значение false.

  2. Задайте для параметра RedirectStandardError значение true.

  3. Добавьте обработчик событий в ErrorDataReceived событие. Обработчик событий должен соответствовать System.Diagnostics.DataReceivedEventHandler сигнатуре делегата.

  4. Запустите Process.

  5. Вызовите метод BeginErrorReadLine для Process . Этот вызов запускает асинхронные операции чтения для StandardError .

При запуске асинхронных операций чтения обработчик событий вызывается каждый раз, когда связанный объект Process записывает строку текста в свой StandardError поток.

Операцию асинхронного чтения можно отменить, вызвав CancelErrorRead . Операция чтения может быть отменена вызывающим объектом или обработчиком событий. После отмены можно снова вызвать метод, BeginErrorReadLine чтобы возобновить асинхронные операции чтения.

Примечание

В перенаправленном потоке нельзя смешивать асинхронные и синхронные операции чтения. После открытия перенаправленного потока Process в асинхронном или синхронном режиме все последующие операции чтения в этом потоке должны находиться в том же режиме. Например, не следует следовать за BeginErrorReadLine вызовом в ReadLine StandardError потоке или наоборот. Однако можно считывать два разных потока в разных режимах. Например, можно вызвать метод BeginErrorReadLine , а затем вызвать метод ReadLine для StandardOutput потока.

Применяется к

См. также раздел