Bagikan melalui

ProcessStartInfo.RedirectStandardError Properti

  • Referensi

Definisi

Ruang nama:
System.Diagnostics
Rakitan:
System.Diagnostics.Process.dll
Rakitan:
System.dll
Rakitan:
netstandard.dll
Sumber:
ProcessStartInfo.cs
Sumber:
ProcessStartInfo.cs
Sumber:
ProcessStartInfo.cs

Mendapatkan atau menetapkan nilai yang menunjukkan apakah output kesalahan aplikasi ditulis ke StandardError aliran.

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

Nilai Properti

Boolean

true jika output kesalahan harus ditulis ke StandardError; jika tidak, false. Default adalah false.

Contoh

Contoh berikut menggunakan net use perintah bersama dengan argumen yang disediakan pengguna untuk memetakan sumber daya jaringan. Kemudian membaca aliran kesalahan standar perintah net dan menulisnya ke konsol.

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

Keterangan

Process Saat menulis teks ke aliran kesalahan standarnya, teks tersebut biasanya ditampilkan di konsol. Dengan mengalihkan StandardError aliran, Anda dapat memanipulasi atau menekan output kesalahan proses. Misalnya, Anda dapat memfilter teks, memformatnya secara berbeda, atau menulis output ke konsol dan file log yang ditunjuk.

Catatan

Anda harus mengatur UseShellExecute ke false jika Anda ingin mengatur RedirectStandardError ke true. Jika tidak, membaca dari StandardError aliran akan melemparkan pengecualian.

Aliran yang dialihkan StandardError dapat dibaca secara sinkron atau asinkron. Metode seperti Read, ReadLine dan ReadToEnd melakukan operasi baca sinkron pada aliran output kesalahan proses. Operasi baca sinkron ini tidak selesai sampai penulisan terkait Process ke alirannya StandardError , atau menutup aliran.

Sebaliknya, BeginErrorReadLine memulai operasi baca asinkron pada StandardError aliran. Metode ini memungkinkan penanganan aktivitas yang ditunjuk untuk output aliran dan segera kembali ke pemanggil, yang dapat melakukan pekerjaan lain saat output aliran diarahkan ke penanganan aktivitas.

Catatan

Aplikasi yang memproses output asinkron harus memanggil Process.WaitForExit metode untuk memastikan bahwa buffer output telah dibersihkan.

Operasi baca sinkron memperkenalkan dependensi antara pembacaan pemanggil dari StandardError aliran dan penulisan proses anak ke aliran tersebut. Dependensi ini dapat menyebabkan kondisi kebuntuan. Ketika pemanggil membaca dari aliran yang dialihkan dari proses anak, itu tergantung pada anak. Penelepon menunggu operasi baca hingga anak menulis ke aliran atau menutup aliran. Ketika proses anak menulis data yang cukup untuk mengisi aliran yang dialihkan, itu tergantung pada induknya. Proses anak menunggu operasi tulis berikutnya hingga induk membaca dari aliran penuh atau menutup aliran. Kondisi kebuntuan menghasilkan ketika pemanggil dan proses anak menunggu satu sama lain untuk menyelesaikan operasi, dan tidak dapat dilanjutkan. Anda dapat menghindari kebuntuan dengan mengevaluasi dependensi antara pemanggil dan proses anak.

Dua contoh terakhir di bagian ini menggunakan Start metode untuk meluncurkan executable bernama Write500Lines.exe. Contoh berikut berisi kode sumbernya.

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.

Contoh berikut menunjukkan cara membaca dari aliran kesalahan yang dialihkan dan menunggu proses anak keluar. Ini menghindari kondisi kebuntuan dengan memanggil p.StandardError.ReadToEnd sebelum p.WaitForExit. Kondisi kebuntuan dapat mengakibatkan proses induk memanggil p.WaitForExit sebelumnya p.StandardError.ReadToEnd dan proses anak menulis teks yang cukup untuk mengisi aliran yang dialihkan. Proses induk akan menunggu tanpa batas waktu agar proses anak keluar. Proses anak akan menunggu tanpa batas waktu bagi induk untuk membaca dari aliran penuh 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.

Ada masalah serupa saat Anda membaca semua teks dari output standar dan aliran kesalahan standar. Kode C# berikut, misalnya, melakukan operasi baca pada kedua aliran. Ini menghindari kondisi kebuntuan dengan melakukan operasi baca asinkron pada StandardError aliran. Kondisi kebuntuan menghasilkan jika panggilan p.StandardOutput.ReadToEnd proses induk diikuti oleh p.StandardError.ReadToEnd dan proses anak menulis teks yang cukup untuk mengisi aliran kesalahannya. Proses induk akan menunggu tanpa batas waktu agar proses anak menutup alirannya StandardOutput . Proses anak akan menunggu tanpa batas waktu bagi induk untuk membaca dari aliran penuh 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.

Anda dapat menggunakan operasi baca asinkron untuk menghindari dependensi ini dan potensi kebuntuannya. Secara bergantian, Anda dapat menghindari kondisi kebuntuan dengan membuat dua utas dan membaca output setiap aliran pada utas terpisah.

Berlaku untuk

Lihat juga