UdpClient.EndReceive(IAsyncResult, IPEndPoint) Methode

Definition

Namespace:

System.Net.Sockets

Assembly:

System.Net.Sockets.dll

Quelle:

UDPClient.cs

Beendet einen ausstehenden asynchronen Empfang.

public:
 cli::array <System::Byte> ^ EndReceive(IAsyncResult ^ asyncResult, System::Net::IPEndPoint ^ % remoteEP);

public byte[] EndReceive (IAsyncResult asyncResult, ref System.Net.IPEndPoint? remoteEP);

member this.EndReceive : IAsyncResult * IPEndPoint -> byte[]

Public Function EndReceive (asyncResult As IAsyncResult, ByRef remoteEP As IPEndPoint) As Byte()

Parameter

asyncResult

IAsyncResult

Ein IAsyncResult-Objekt, das durch einen Aufruf von BeginReceive(AsyncCallback, Object) zurückgegeben wird.

remoteEP

IPEndPoint

Der angegebene Remoteendpunkt.

Gibt zurück

Byte[]

Bei Erfolg wird ein Array von Bytes zurückgegeben, dass Datagrammdaten enthält.

Ausnahmen

ArgumentNullException

asyncResult ist null.

ArgumentException

asyncResult wurde nicht durch einen Aufruf der BeginReceive(AsyncCallback, Object)-Methode zurückgegeben.

InvalidOperationException

EndReceive(IAsyncResult, IPEndPoint) wurde bereits für den asynchronen Lesevorgang aufgerufen.

SocketException

Fehler beim Zugriff auf den Socket.

ObjectDisposedException

Der zugrunde liegende Socket wurde geschlossen.

Beispiele

Im folgenden Codebeispiel wird BeginSend verwendet, um einen asynchronen Empfang einer Serverantwort abzuschließen.

private:
    static int listenPort = 13000;

public:
    value struct UdpState
    {
    public:
        UdpClient^ udpClient;
        IPEndPoint^ ipEndPoint;
    };

    static bool isMessageReceived;

    static void ReceiveCallback(IAsyncResult^ asyncResult)
    {
        UdpClient^ udpClient =
            ((UdpState)(asyncResult->AsyncState)).udpClient;
        IPEndPoint^ ipEndPoint =
            ((UdpState)(asyncResult->AsyncState)).ipEndPoint;

        array<Byte>^ receiveBytes =
            udpClient->EndReceive(asyncResult, ipEndPoint);
        String^ receiveString =
            Encoding::ASCII->GetString(receiveBytes);

        Console::WriteLine("Received: {0}", receiveString);
        isMessageReceived = true;
    }

    static void ReceiveMessages()
    {
        // Receive a message and write it to the console.
        IPEndPoint^ ipEndPoint = gcnew IPEndPoint(IPAddress::Any, listenPort);
        UdpClient^ udpClient = gcnew UdpClient(ipEndPoint);

        UdpState^ udpState = gcnew UdpState();
        udpState->ipEndPoint = ipEndPoint;
        udpState->udpClient = udpClient;

        Console::WriteLine("listening for messages");
        udpClient->BeginReceive(gcnew AsyncCallback(ReceiveCallback),
            udpState);

        // Do some work while we wait for a message. For this example,
        // we'll just sleep
        while (!isMessageReceived)
        {
            Thread::Sleep(100);
        }
    }

public struct UdpState
{
    public UdpClient u;
    public IPEndPoint e;
}

public static bool messageReceived = false;

public static void ReceiveCallback(IAsyncResult ar)
{
    UdpClient u = ((UdpState)(ar.AsyncState)).u;
    IPEndPoint e = ((UdpState)(ar.AsyncState)).e;

    byte[] receiveBytes = u.EndReceive(ar, ref e);
    string receiveString = Encoding.ASCII.GetString(receiveBytes);

    Console.WriteLine($"Received: {receiveString}");
    messageReceived = true;
}

public static void ReceiveMessages()
{
    // Receive a message and write it to the console.
    IPEndPoint e = new IPEndPoint(IPAddress.Any, s_listenPort);
    UdpClient u = new UdpClient(e);

    UdpState s = new UdpState();
    s.e = e;
    s.u = u;

    Console.WriteLine("listening for messages");
    u.BeginReceive(new AsyncCallback(ReceiveCallback), s);

    // Do some work while we wait for a message. For this example, we'll just sleep
    while (!messageReceived)
    {
        Thread.Sleep(100);
    }
}

Hinweise

Diese Methode blockiert, bis der Vorgang abgeschlossen ist.

Um diesen Vorgang synchron auszuführen, verwenden Sie die Receive -Methode.