DataReceivedEventArgs.Data Propriété

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

Valeur de propriété

Ligne qui a été écrite par un Process associé à son StandardOutput redirigé ou à son flux StandardError.

Exemples

L’exemple de code suivant illustre un gestionnaire d’événements simple associé à l’événement OutputDataReceived . Le gestionnaire d’événements reçoit les lignes de texte du flux redirigé StandardOutput , met en forme le texte et écrit le texte à l’écran.

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

Remarques

Lorsque vous redirigez le StandardOutput flux ou StandardError d’un Process vers votre gestionnaire d’événements, un événement est déclenché chaque fois que le processus écrit une ligne dans le flux redirigé. La Data propriété est la ligne que le Process a écrite dans le flux de sortie redirigé. Votre gestionnaire d’événements peut utiliser la propriété pour filtrer la Data sortie du processus ou écrire la sortie dans un autre emplacement. Par exemple, vous pouvez créer un gestionnaire d’événements qui stocke toutes les lignes de sortie des erreurs dans un fichier journal des erreurs désigné.

Une ligne est définie comme une séquence de caractères suivie d’un flux de ligne (« \n ») ou d’un retour chariot immédiatement suivi d’un flux de ligne (« \r\n »). Les caractères de ligne sont encodés à l’aide de la page de codes ANSI système par défaut. La Data propriété n’inclut pas le retour chariot de fin ou le flux de ligne.

Lorsque le flux redirigé est fermé, une ligne Null est envoyée au gestionnaire d’événements. Assurez-vous que votre gestionnaire d’événements vérifie correctement la Data propriété avant d’y accéder. Par exemple, vous pouvez utiliser la méthode String.IsNullOrEmpty statique pour valider la Data propriété dans votre gestionnaire d’événements.

S’applique à