UdpClient.BeginReceive(AsyncCallback, Object) Metoda

Definicja

Przestrzeń nazw:

System.Net.Sockets

Zestaw:

System.Net.Sockets.dll

Źródło:

UDPClient.cs

Odbiera datagram z hosta zdalnego asynchronicznie.

public:
 IAsyncResult ^ BeginReceive(AsyncCallback ^ requestCallback, System::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

Parametry

requestCallback

AsyncCallback

Delegat AsyncCallback , który odwołuje się do metody wywoływania po zakończeniu operacji.

state

Object

Obiekt zdefiniowany przez użytkownika, który zawiera informacje o operacji odbierania. Ten obiekt jest przekazywany do delegata po zakończeniu requestCallback operacji.

Zwraca

IAsyncResult

IAsyncResult Obiekt, który odwołuje się do odbierania asynchronicznego.

Przykłady

Poniższy przykład kodu używa BeginReceive metody do asynchronicznego odbierania odpowiedzi serwera.

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);
    }
}

Uwagi

Operacja asynchroniczna BeginReceive musi zostać ukończona przez wywołanie EndReceive metody . Zazwyczaj metoda jest wywoływana przez delegata requestCallback .

Ta metoda nie blokuje się, dopóki operacja nie zostanie ukończona. Aby zablokować, dopóki operacja nie zostanie ukończona, użyj Receive metody .

Aby uzyskać szczegółowe informacje na temat używania asynchronicznego modelu programowania, zobacz Wywoływanie metod synchronicznych asynchronicznie.