Поделиться через

ProcessStartInfo.RedirectStandardError Свойство

  • Ссылка

Определение

Пространство имен:
System.Diagnostics
Сборка:
System.Diagnostics.Process.dll
Сборка:
System.dll
Сборка:
netstandard.dll
Исходный код:
ProcessStartInfo.cs
Исходный код:
ProcessStartInfo.cs
Исходный код:
ProcessStartInfo.cs

Получает или задает значение, позволяющее определить, записываются ли выходные данные об ошибках приложения в поток StandardError.

public:
 property bool RedirectStandardError { bool get(); void set(bool value); };
public bool RedirectStandardError { get; set; }
member this.RedirectStandardError : bool with get, set
Public Property RedirectStandardError As Boolean

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

Boolean

Значениеtrue , если выходные данные должны записываться в StandardError; в противном случае — значение false. Значение по умолчанию — false.

Примеры

В следующем примере команда используется net use вместе с предоставленным пользователем аргументом для сопоставления сетевого ресурса. Затем он считывает стандартный поток ошибок команды net и записывает его в консоль.

Process^ myProcess = gcnew Process;
ProcessStartInfo^ myProcessStartInfo = gcnew ProcessStartInfo( "net ",String::Concat( "use ", args[ 0 ] ) );

myProcessStartInfo->UseShellExecute = false;
myProcessStartInfo->RedirectStandardError = true;
myProcess->StartInfo = myProcessStartInfo;
myProcess->Start();

StreamReader^ myStreamReader = myProcess->StandardError;
// Read the standard error of net.exe and write it on to console.
Console::WriteLine( myStreamReader->ReadLine() );
myProcess->Close();

using (Process myProcess = new Process())
{
    ProcessStartInfo myProcessStartInfo = new ProcessStartInfo("net ", "use " + args[0]);

    myProcessStartInfo.UseShellExecute = false;
    myProcessStartInfo.RedirectStandardError = true;
    myProcess.StartInfo = myProcessStartInfo;
    myProcess.Start();

    StreamReader myStreamReader = myProcess.StandardError;
    // Read the standard error of net.exe and write it on to console.
    Console.WriteLine(myStreamReader.ReadLine());
}

Using myProcess As New Process()
    Dim myProcessStartInfo As New ProcessStartInfo("net ", "use " + args(0))

    myProcessStartInfo.UseShellExecute = False
    myProcessStartInfo.RedirectStandardError = True
    myProcess.StartInfo = myProcessStartInfo
    myProcess.Start()

    Dim myStreamReader As StreamReader = myProcess.StandardError
    ' Read the standard error of net.exe and write it on to console.
    Console.WriteLine(myStreamReader.ReadLine())
End Using

Комментарии

Когда объект записывает текст в свой стандартный Process поток ошибок, этот текст обычно отображается в консоли. Перенаправляя StandardError поток, можно управлять выводом ошибок процесса или подавлять его. Например, можно отфильтровать текст, отформатировать его по-другому или записать выходные данные как в консоль, так и в назначенный файл журнала.

Примечание

Если вы хотите задать значение RedirectStandardErrortrue, необходимо задать значение UseShellExecutefalse . В противном случае при чтении StandardError из потока создается исключение.

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

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

Примечание

Приложение, обрабатывающее асинхронные выходные данные, должно вызвать Process.WaitForExit метод , чтобы убедиться, что выходной буфер был сброшен.

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

В двух последних примерах в этом разделе используется Start метод для запуска исполняемого файла с именемWrite500Lines.exe. В следующем примере содержится его исходный код.

using System;
using System.IO;

public class Example3
{
   public static void Main()
   {
      for (int ctr = 0; ctr < 500; ctr++)
         Console.WriteLine($"Line {ctr + 1} of 500 written: {ctr + 1/500.0:P2}");

      Console.Error.WriteLine("\nSuccessfully wrote 500 lines.\n");
   }
}
// The example displays the following output:
//      The last 50 characters in the output stream are:
//      ' 49,800.20%
//      Line 500 of 500 written: 49,900.20%
//'
//
//      Error stream: Successfully wrote 500 lines.

Imports System.IO

Public Module Example
   Public Sub Main()
      For ctr As Integer = 0 To 499
         Console.WriteLine($"Line {ctr + 1} of 500 written: {ctr + 1/500.0:P2}")
      Next

      Console.Error.WriteLine($"{vbCrLf}Successfully wrote 500 lines.{vbCrLf}")
   End Sub
End Module
' The example displays the following output:
'      The last 50 characters in the output stream are:
'      ' 49,800.20%
'      Line 500 of 500 written: 49,900.20%
'
'
'      Error stream: Successfully wrote 500 lines.

В следующем примере показано, как считывать данные из перенаправленного потока ошибок и ждать завершения дочернего процесса. Он позволяет избежать взаимоблокировки, вызывая p.StandardError.ReadToEnd перед p.WaitForExit. Условие взаимоблокировки может возникнуть, если родительский процесс вызывает p.WaitForExit до p.StandardError.ReadToEnd , а дочерний процесс записывает достаточно текста для заполнения перенаправленного потока. Родительский процесс будет бесконечно ожидать выхода дочернего процесса. Дочерний процесс будет бесконечно ожидать чтения родительского элемента из полного StandardError потока.

using System;
using System.Diagnostics;

public class Example
{
   public static void Main()
   {
      var p = new Process();  
      p.StartInfo.UseShellExecute = false;  
      p.StartInfo.RedirectStandardError = true;  
      p.StartInfo.FileName = "Write500Lines.exe";  
      p.Start();  

      // To avoid deadlocks, always read the output stream first and then wait.  
      string output = p.StandardError.ReadToEnd();  
      p.WaitForExit();

      Console.WriteLine($"\nError stream: {output}");
   }
}
// The end of the output produced by the example includes the following:
//      Error stream:
//      Successfully wrote 500 lines.

Imports System.Diagnostics

Public Module Example
    Public Sub Main()
        Dim p As New Process()
        p.StartInfo.UseShellExecute = False  
        p.StartInfo.RedirectStandardError = True  
        p.StartInfo.FileName = "Write500Lines.exe"  
        p.Start() 

        ' To avoid deadlocks, always read the output stream first and then wait.  
        Dim output As String = p.StandardError.ReadToEnd()  
        p.WaitForExit()

        Console.WriteLine($"{vbCrLf}Error stream: {output}")
    End Sub
End Module
' The end of the output produced by the example includes the following:
'      Error stream:
'      Successfully wrote 500 lines.

Аналогичная проблема возникает при чтении всего текста из стандартных выходных данных и стандартных потоков ошибок. Например, следующий код C# выполняет операцию чтения в обоих потоках. Это позволяет избежать условия взаимоблокировки, выполняя асинхронные операции чтения в потоке StandardError . Условие взаимоблокировки возникает, если родительский процесс вызывает p.StandardOutput.ReadToEndp.StandardError.ReadToEnd и дочерний процесс записывает достаточно текста для заполнения потока ошибок. Родительский процесс будет бесконечно ожидать закрытия дочернего процесса своего StandardOutput потока. Дочерний процесс будет бесконечно ожидать чтения родительского элемента из полного StandardError потока.

using System;
using System.Diagnostics;

public class Example
{
   public static void Main()
   {
      var p = new Process();  
      p.StartInfo.UseShellExecute = false;  
      p.StartInfo.RedirectStandardOutput = true;  
      string eOut = null;
      p.StartInfo.RedirectStandardError = true;
      p.ErrorDataReceived += new DataReceivedEventHandler((sender, e) => 
                                 { eOut += e.Data; });
      p.StartInfo.FileName = "Write500Lines.exe";  
      p.Start();  

      // To avoid deadlocks, use an asynchronous read operation on at least one of the streams.  
      p.BeginErrorReadLine();
      string output = p.StandardOutput.ReadToEnd();  
      p.WaitForExit();

      Console.WriteLine($"The last 50 characters in the output stream are:\n'{output.Substring(output.Length - 50)}'");
      Console.WriteLine($"\nError stream: {eOut}");
   }
}
// The example displays the following output:
//      The last 50 characters in the output stream are:
//      ' 49,800.20%
//      Line 500 of 500 written: 49,900.20%
//      '
//
//      Error stream: Successfully wrote 500 lines.

Imports System.Diagnostics

Public Module Example
   Public Sub Main()
      Dim p As New Process()  
      p.StartInfo.UseShellExecute = False  
      p.StartInfo.RedirectStandardOutput = True  
      Dim eOut As String = Nothing
      p.StartInfo.RedirectStandardError = True
      AddHandler p.ErrorDataReceived, Sub(sender, e) eOut += e.Data 
      p.StartInfo.FileName = "Write500Lines.exe"  
      p.Start()  

      ' To avoid deadlocks, use an asynchronous read operation on at least one of the streams.  
      p.BeginErrorReadLine()
      Dim output As String = p.StandardOutput.ReadToEnd()  
      p.WaitForExit()

      Console.WriteLine($"The last 50 characters in the output stream are:{vbCrLf}'{output.Substring(output.Length - 50)}'")
      Console.WriteLine($"{vbCrLf}Error stream: {eOut}")
   End Sub
End Module
' The example displays the following output:
'      The last 50 characters in the output stream are:
'      ' 49,800.20%
'      Line 500 of 500 written: 49,900.20%
'      '
'
'      Error stream: Successfully wrote 500 lines.

Можно использовать асинхронные операции чтения, чтобы избежать этих зависимостей и их возможности взаимоблокировки. Кроме того, можно избежать условия взаимоблокировки, создав два потока и считывая выходные данные каждого потока в отдельном потоке.

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

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