Process.StandardError Properti

Definisi

Ruang nama:

System.Diagnostics

Rakitan:

System.Diagnostics.Process.dll

Sumber:

Process.cs

Mendapatkan aliran yang digunakan untuk membaca output kesalahan aplikasi.

public:
 property System::IO::StreamReader ^ StandardError { System::IO::StreamReader ^ get(); };

public System.IO.StreamReader StandardError { get; }

member this.StandardError : System.IO.StreamReader

Public ReadOnly Property StandardError As StreamReader

Nilai Properti

StreamReader

Yang StreamReader dapat digunakan untuk membaca aliran kesalahan standar aplikasi.

Pengecualian

InvalidOperationException

Aliran StandardError belum ditentukan untuk pengalihan; pastikan RedirectStandardError diatur ke true dan UseShellExecute diatur ke false.

-atau-

Aliran StandardError telah dibuka untuk operasi baca asinkron dengan BeginErrorReadLine().

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

Untuk menggunakan StandardError, Anda harus mengatur ProcessStartInfo.UseShellExecute ke false, dan Anda harus mengatur ProcessStartInfo.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.

Operasi baca sinkron memperkenalkan dependensi antara pembacaan pemanggil dari StandardError aliran dan penulisan proses anak ke aliran tersebut. Dependensi ini dapat mengakibatkan kondisi kebuntuan. Ketika pemanggil membaca dari aliran yang dialihkan dari proses anak, itu tergantung pada anak. Pemanggil menunggu pada 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 pada 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. Contoh berikut melakukan operasi baca di 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.

Catatan

Anda tidak dapat mencampur operasi baca asinkron dan sinkron pada aliran yang dialihkan. Setelah aliran yang dialihkan dibuka Process dalam mode asinkron atau sinkron, semua operasi baca lebih lanjut pada aliran tersebut harus dalam mode yang sama. Misalnya, jangan ikuti BeginErrorReadLine dengan panggilan ke ReadLine di StandardError aliran, atau sebaliknya. Namun, Anda dapat membaca dua aliran yang berbeda dalam mode yang berbeda. Misalnya, Anda dapat memanggil BeginOutputReadLine lalu memanggil ReadLineStandardError aliran.

Lihat juga

• StandardInput
• StandardOutput
• RedirectStandardError