UdpClient.BeginReceive(AsyncCallback, Object) Methode

Referenz

Definition

Namespace:: System.Net.Sockets

Assembly:: System.Net.Sockets.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Quelle:: UDPClient.cs

Quelle:: UDPClient.cs

Quelle:: UDPClient.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Empfängt asynchron ein Datagramm von einem Remotehost.

public:
 IAsyncResult ^ BeginReceive(AsyncCallback ^ requestCallback, System::Object ^ state);

public IAsyncResult BeginReceive (AsyncCallback? requestCallback, object? state);

public IAsyncResult BeginReceive (AsyncCallback requestCallback, object state);

member this.BeginReceive : AsyncCallback * obj -> IAsyncResult

Public Function BeginReceive (requestCallback As AsyncCallback, state As Object) As IAsyncResult

Parameter

requestCallback: AsyncCallback

Ein AsyncCallback-Delegat, der auf die Methode verweist, die bei Abschluss des Vorgangs aufgerufen werden soll.

state: Object

Ein benutzerdefiniertes Objekt, das Informationen über den Empfangsvorgang enthält. Dieses Objekt wird bei Abschluss des Vorgangs an den requestCallback-Delegaten übergeben.

Gibt zurück

IAsyncResult

Ein IAsyncResult-Objekt, das auf den asynchronen Empfang verweist.

Beispiele

Im folgenden Codebeispiel wird verwendet BeginReceive , um asynchron eine Serverantwort zu empfangen.

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

Der asynchrone BeginReceive Vorgang muss durch Aufrufen der EndReceive -Methode abgeschlossen werden. In der Regel wird die -Methode vom requestCallback Delegaten aufgerufen.

Diese Methode wird erst blockiert, wenn der Vorgang abgeschlossen ist. Um zu blockieren, bis der Vorgang abgeschlossen ist, verwenden Sie die Receive -Methode.

Ausführliche Informationen zur Verwendung des asynchronen Programmiermodells finden Sie unter Asynchrones Aufrufen synchroner Methoden.

Gilt für:

Freigeben über