SerialPort.DataReceived Ereignis

Definition

Gibt an, dass Daten über einen Port empfangen wurden, der durch das SerialPort-Objekt dargestellt wird.Indicates that data has been received through a port represented by the SerialPort object.

public:
 event System::IO::Ports::SerialDataReceivedEventHandler ^ DataReceived;
public event System.IO.Ports.SerialDataReceivedEventHandler DataReceived;
member this.DataReceived : System.IO.Ports.SerialDataReceivedEventHandler 
Public Event DataReceived As SerialDataReceivedEventHandler 

Beispiele

In diesem Beispiel wird SerialDataReceivedEventHandler ein DataReceived hinzugefügt, um alle verfügbaren Daten zu lesen, die am COM1-Port empfangen wurden.This example adds a SerialDataReceivedEventHandler to DataReceived to read all the available data received on the COM1 port. Beachten Sie, dass zum Testen dieses Codes Hardware an COM1 angefügt werden muss, die Daten sendet.Note that to test this code it is necessary to have hardware attached to COM1 that will send data.

#using <System.dll>

using namespace System;
using namespace System::IO::Ports;

ref class PortDataReceived
{
public:
    static void Main()
    {
        SerialPort^ mySerialPort = gcnew SerialPort("COM1");

        mySerialPort->BaudRate = 9600;
        mySerialPort->Parity = Parity::None;
        mySerialPort->StopBits = StopBits::One;
        mySerialPort->DataBits = 8;
        mySerialPort->Handshake = Handshake::None;
        mySerialPort->RtsEnable = true;

        mySerialPort->DataReceived += gcnew SerialDataReceivedEventHandler(DataReceivedHandler);

        mySerialPort->Open();

        Console::WriteLine("Press any key to continue...");
        Console::WriteLine();
        Console::ReadKey();
        mySerialPort->Close();
    }

private:
    static void DataReceivedHandler(
                        Object^ sender,
                        SerialDataReceivedEventArgs^ e)
    {
        SerialPort^ sp = (SerialPort^)sender;
        String^ indata = sp->ReadExisting();
        Console::WriteLine("Data Received:");
        Console::Write(indata);
    }
};

int main()
{
    PortDataReceived::Main();
}
using System;
using System.IO.Ports;

class PortDataReceived
{
    public static void Main()
    {
        SerialPort mySerialPort = new SerialPort("COM1");

        mySerialPort.BaudRate = 9600;
        mySerialPort.Parity = Parity.None;
        mySerialPort.StopBits = StopBits.One;
        mySerialPort.DataBits = 8;
        mySerialPort.Handshake = Handshake.None;
        mySerialPort.RtsEnable = true;

        mySerialPort.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

        mySerialPort.Open();

        Console.WriteLine("Press any key to continue...");
        Console.WriteLine();
        Console.ReadKey();
        mySerialPort.Close();
    }

    private static void DataReceivedHandler(
                        object sender,
                        SerialDataReceivedEventArgs e)
    {
        SerialPort sp = (SerialPort)sender;
        string indata = sp.ReadExisting();
        Console.WriteLine("Data Received:");
        Console.Write(indata);
    }
}
Imports System.IO.Ports

Class PortDataReceived
    Public Shared Sub Main()
        Dim mySerialPort As New SerialPort("COM1")

        mySerialPort.BaudRate = 9600
        mySerialPort.Parity = Parity.None
        mySerialPort.StopBits = StopBits.One
        mySerialPort.DataBits = 8
        mySerialPort.Handshake = Handshake.None
        mySerialPort.RtsEnable = True

        AddHandler mySerialPort.DataReceived, AddressOf DataReceivedHandler

        mySerialPort.Open()

        Console.WriteLine("Press any key to continue...")
        Console.WriteLine()
        Console.ReadKey()
        mySerialPort.Close()
    End Sub

    Private Shared Sub DataReceivedHandler(
                        sender As Object,
                        e As SerialDataReceivedEventArgs)
        Dim sp As SerialPort = CType(sender, SerialPort)
        Dim indata As String = sp.ReadExisting()
        Console.WriteLine("Data Received:")
        Console.Write(indata)
    End Sub
End Class

Hinweise

Daten Ereignisse können von einem der Elemente in der SerialData -Enumeration verursacht werden.Data events can be caused by any of the items in the SerialData enumeration. Da das Betriebssystem bestimmt, ob dieses Ereignis oder nicht, werden möglicherweise nicht alle Paritätsfehler gemeldet.Because the operating system determines whether to raise this event or not, not all parity errors may be reported.

Das DataReceived -Ereignis wird auch ausgelöst, wenn ein EOF-Zeichen empfangen wird, unabhängig von der Anzahl von Bytes im internen Eingabepuffer und dem Wert ReceivedBytesThreshold der-Eigenschaft.The DataReceived event is also raised if an Eof character is received, regardless of the number of bytes in the internal input buffer and the value of the ReceivedBytesThreshold property.

PinChanged- DataReceived,- ErrorReceived und-Ereignisse können in falscher Reihenfolge aufgerufen werden, und es kann zu einer geringfügigen Verzögerung zwischen dem Zeitpunkt, zu dem der zugrunde liegende Stream den Fehler meldet, und dem Zeitpunkt, zu dem der EreignisPinChanged, DataReceived, and ErrorReceived events may be called out of order, and there may be a slight delay between when the underlying stream reports the error and when the event handler is executed. Es kann jeweils nur ein Ereignishandler ausgeführt werden.Only one event handler can execute at a time.

Das DataReceived Ereignis wird für jedes empfangene Byte nicht garantiert ausgelöst.The DataReceived event is not guaranteed to be raised for every byte received. Verwenden Sie BytesToRead die-Eigenschaft, um zu bestimmen, wie viele Daten im Puffer gelesen werden sollen.Use the BytesToRead property to determine how much data is left to be read in the buffer.

Das DataReceived -Ereignis wird für einen sekundären Thread ausgelöst, wenn Daten SerialPort vom-Objekt empfangen werden.The DataReceived event is raised on a secondary thread when data is received from the SerialPort object. Da dieses Ereignis auf einem sekundären Thread ausgelöst wird, nicht auf dem Haupt Thread, könnte der Versuch, einige Elemente im Haupt Thread zu ändern, wie z. b. Benutzeroberflächen Elemente, eine Threading Ausnahme auslöst.Because this event is raised on a secondary thread, and not the main thread, attempting to modify some elements in the main thread, such as UI elements, could raise a threading exception. Wenn es erforderlich ist, Elemente in der Haupt Form -oder Control-Datei zu ändern, müssen Sie die Änderungsanforderungen mit wieder verwenden Invoke, wodurch die Arbeit im richtigen Thread erfolgt.If it is necessary to modify elements in the main Form or Control, post change requests back using Invoke, which will do the work on the proper thread.

Weitere Informationen zur Behandlung von Ereignissen finden Sie unter behandeln und Auslösen von Ereignissen.For more information about handling events, see Handling and Raising Events.

Gilt für: