SerialPort.DataReceived Evento

Definição

Indica que os dados foram recebidos por meio de uma porta representada pelo objeto 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 

Exemplos

Este exemplo adiciona um SerialDataReceivedEventHandler ao DataReceived para ler todos os dados disponíveis recebidos na porta COM1.This example adds a SerialDataReceivedEventHandler to DataReceived to read all the available data received on the COM1 port. Observe que, para testar esse código, é necessário ter um hardware anexado a COM1 que enviará dados.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

Comentários

Os eventos de dados podem ser causados por qualquer um dos itens na enumeração SerialData.Data events can be caused by any of the items in the SerialData enumeration. Como o sistema operacional determina se esse evento deve ser gerado ou não, nem todos os erros de paridade podem ser relatados.Because the operating system determines whether to raise this event or not, not all parity errors may be reported.

O evento DataReceived também será gerado se um caractere EOF for recebido, independentemente do número de bytes no buffer de entrada interno e do valor da propriedade ReceivedBytesThreshold.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.

os eventos PinChanged, DataReceivede ErrorReceived podem ser chamados fora de ordem, e pode haver um pequeno atraso entre o momento em que o fluxo subjacente relata o erro e quando o manipulador de eventos é executado.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. Somente um manipulador de eventos pode ser executado de cada vez.Only one event handler can execute at a time.

Não há garantia de que o evento DataReceived seja gerado para cada byte recebido.The DataReceived event is not guaranteed to be raised for every byte received. Use a propriedade BytesToRead para determinar a quantidade de dados que será deixada para ser lida no buffer.Use the BytesToRead property to determine how much data is left to be read in the buffer.

O evento DataReceived é gerado em um thread secundário quando os dados são recebidos do objeto SerialPort.The DataReceived event is raised on a secondary thread when data is received from the SerialPort object. Como esse evento é gerado em um thread secundário, e não no thread principal, a tentativa de modificar alguns elementos no thread principal, como elementos da interface do usuário, pode gerar uma exceção de 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 for necessário modificar elementos no Form principal ou Control, poste solicitações de alteração novamente usando Invoke, o que fará o trabalho no thread adequado.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.

Para obter mais informações sobre como manipular eventos, consulte manipulando e gerando eventos.For more information about handling events, see Handling and Raising Events.

Aplica-se a