SerialPort.DataReceived SerialPort.DataReceived SerialPort.DataReceived SerialPort.DataReceived Event

Definizione

Indica che i dati sono stati ricevuti tramite una porta rappresentata dall'oggetto SerialPort.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 

Esempi

In questo esempio viene SerialDataReceivedEventHandler aggiunto DataReceived un oggetto a per leggere tutti i dati disponibili ricevuti sulla porta COM1.This example adds a SerialDataReceivedEventHandler to DataReceived to read all the available data received on the COM1 port. Si noti che per testare questo codice è necessario che l'hardware sia collegato alla porta COM1 che invierà i dati.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

Commenti

Gli eventi dati possono essere causati da uno qualsiasi degli elementi SerialData dell'enumerazione.Data events can be caused by any of the items in the SerialData enumeration. Poiché il sistema operativo determina se generare o meno questo evento, non è possibile che vengano segnalati tutti gli errori di parità.Because the operating system determines whether to raise this event or not, not all parity errors may be reported.

L' DataReceived evento viene generato anche se viene ricevuto un carattere EOF, indipendentemente dal numero di byte nel buffer di input interno e dal valore ReceivedBytesThreshold della proprietà.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.

PinChangedgli DataReceivedeventi, ErrorReceived e possono essere chiamati fuori ordine e potrebbe verificarsi un lieve ritardo tra il momento in cui il flusso sottostante segnala l'errore e quando viene eseguito il gestore eventi.PinChanged, 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. È possibile eseguire un solo gestore eventi alla volta.Only one event handler can execute at a time.

Non DataReceived è garantito che l'evento venga generato per ogni byte ricevuto.The DataReceived event is not guaranteed to be raised for every byte received. Utilizzare la BytesToRead proprietà per determinare la quantità di dati rimanenti da leggere nel buffer.Use the BytesToRead property to determine how much data is left to be read in the buffer.

L' DataReceived evento viene generato in un thread secondario quando i dati vengono ricevuti SerialPort dall'oggetto.The DataReceived event is raised on a secondary thread when data is received from the SerialPort object. Poiché questo evento viene generato in un thread secondario e non nel thread principale, il tentativo di modificare alcuni elementi nel thread principale, ad esempio gli elementi dell'interfaccia utente, potrebbe generare un'eccezione di Threading.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. Se è necessario modificare gli elementi nell'oggetto Main Form o Control, inviare le richieste di modifica utilizzando Invoke, che eseguirà il lavoro sul thread appropriato.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.

Per ulteriori informazioni sulla gestione degli eventi, consultare gestione e generazione di eventi.For more information about handling events, see Handling and Raising Events.

Si applica a