DataReceivedEventArgs.Data Eigenschaft

public:
 property System::String ^ Data { System::String ^ get(); };

public string? Data { get; }

public string Data { get; }

member this.Data : string

Public ReadOnly Property Data As String

Eigenschaftswert

Die Zeile, die von einem zugeordneten Process in seinen umgeleiteten StandardOutput-Stream oder StandardError-Stream geschrieben wurde.

Beispiele

Das folgende Codebeispiel veranschaulicht einen einfachen Ereignishandler, der dem OutputDataReceived Ereignis zugeordnet ist. Der Ereignishandler empfängt Textzeilen aus dem umgeleiteten StandardOutput Stream, formatiert den Text und schreibt den Text auf den Bildschirm.

using namespace System;
using namespace System::IO;
using namespace System::Diagnostics;
using namespace System::Text;

ref class StandardAsyncOutputExample
{
private:
    static int lineCount = 0;
    static StringBuilder^ output = nullptr;

public:
    static void Run()
    {
        Process^ process = gcnew Process();
        process->StartInfo->FileName = "ipconfig.exe";
        process->StartInfo->UseShellExecute = false;
        process->StartInfo->RedirectStandardOutput = true;
        output = gcnew StringBuilder();
        process->OutputDataReceived += gcnew DataReceivedEventHandler(OutputHandler);
        process->Start();

        // Asynchronously read the standard output of the spawned process. 
        // This raises OutputDataReceived events for each line of output.
        process->BeginOutputReadLine();
        process->WaitForExit();

        // Write the redirected output to this application's window.
        Console::WriteLine(output);

        process->WaitForExit();
        process->Close();

        Console::WriteLine("\n\nPress any key to exit");
        Console::ReadLine();
    }

private:
    static void OutputHandler(Object^ sender, DataReceivedEventArgs^ e)
    {
        // Prepend line numbers to each line of the output.
        if (!String::IsNullOrEmpty(e->Data))
        {
            lineCount++;
            output->Append("\n[" + lineCount + "]: " + e->Data);
        }
    }
};

int main()
{
    StandardAsyncOutputExample::Run();
}

using System;
using System.IO;
using System.Diagnostics;
using System.Text;

class StandardAsyncOutputExample
{
    private static int lineCount = 0;
    private static StringBuilder output = new StringBuilder();

    public static void Main()
    {
        Process process = new Process();
        process.StartInfo.FileName = "ipconfig.exe";
        process.StartInfo.UseShellExecute = false;
        process.StartInfo.RedirectStandardOutput = true;
        process.OutputDataReceived += new DataReceivedEventHandler((sender, e) =>
        {
            // Prepend line numbers to each line of the output.
            if (!String.IsNullOrEmpty(e.Data))
            {
                lineCount++;
                output.Append("\n[" + lineCount + "]: " + e.Data);
            }
        });

        process.Start();

        // Asynchronously read the standard output of the spawned process.
        // This raises OutputDataReceived events for each line of output.
        process.BeginOutputReadLine();
        process.WaitForExit();

        // Write the redirected output to this application's window.
        Console.WriteLine(output);

        process.WaitForExit();
        process.Close();

        Console.WriteLine("\n\nPress any key to exit.");
        Console.ReadLine();
    }
}

Imports System.IO
Imports System.Diagnostics
Imports System.Text

Module Module1
    Dim lineCount As Integer = 0
    Dim output As StringBuilder = New StringBuilder()

    Sub Main()
        Dim process As New Process()
        process.StartInfo.FileName = "ipconfig.exe"
        process.StartInfo.UseShellExecute = False
        process.StartInfo.RedirectStandardOutput = True
        AddHandler process.OutputDataReceived, AddressOf OutputHandler
        process.Start()

        ' Asynchronously read the standard output of the spawned process. 
        ' This raises OutputDataReceived events for each line of output.
        process.BeginOutputReadLine()
        process.WaitForExit()

        Console.WriteLine(output)

        process.WaitForExit()
        process.Close()

        Console.WriteLine(Environment.NewLine + Environment.NewLine + "Press any key to exit.")
        Console.ReadLine()
    End Sub

    Sub OutputHandler(sender As Object, e As DataReceivedEventArgs)
        If Not String.IsNullOrEmpty(e.Data) Then
            lineCount += 1

            ' Add the text to the collected output.
            output.Append(Environment.NewLine + "[" + lineCount.ToString() + "]: " + e.Data)
        End If
    End Sub
End Module

Hinweise

Wenn Sie den StandardOutputStandardError Oder-Stream eines Process an Ihren Ereignishandler umleiten, wird jedes Mal ein Ereignis ausgelöst, wenn der Prozess eine Zeile in den umgeleiteten Stream schreibt. Die Data -Eigenschaft ist die Zeile, die der Process in den umgeleiteten Ausgabedatenstrom geschrieben hat. Ihr Ereignishandler kann die -Eigenschaft verwenden, um die Data Prozessausgabe zu filtern oder die Ausgabe an einen alternativen Speicherort zu schreiben. Sie können beispielsweise einen Ereignishandler erstellen, der alle Fehlerausgabezeilen in einer angegebenen Fehlerprotokolldatei speichert.

Eine Linie ist definiert als eine Sequenz von Zeichen gefolgt von einem Zeilenvorschub ("\n") oder einer Wagenrückführung unmittelbar gefolgt von einem Zeilenvorschub ("\r\n"). Die Zeilenzeichen werden mithilfe der Standardmäßigen System-ANSI-Codepage codiert. Die Data -Eigenschaft enthält weder den beendenden Wagenrücklauf noch den Zeilenvorschub.

Wenn der umgeleitete Stream geschlossen wird, wird eine NULL-Zeile an den Ereignishandler gesendet. Stellen Sie sicher, dass Ihr Ereignishandler die Data Eigenschaft vor dem Zugriff entsprechend überprüft. Beispielsweise können Sie die statische Methode String.IsNullOrEmpty verwenden, um die Data Eigenschaft in Ihrem Ereignishandler zu überprüfen.

Gilt für: