UdpClient.BeginReceive(AsyncCallback, Object) Méthode

Définition

Espace de noms:
System.Net.Sockets
Assembly:
System.dll
Assembly:
netstandard.dll

Reçoit un datagramme d’un hôte distant de manière asynchrone.

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

Paramètres

requestCallback
AsyncCallback

Délégué AsyncCallback qui fait référence à la méthode à appeler une fois l’opération terminée.

state
Object

Objet défini par l’utilisateur qui contient des informations sur l’opération de réception. Cet objet est transmis au requestCallback délégué une fois l’opération terminée.

Retours

IAsyncResult

Objet IAsyncResult qui fait référence à la réception asynchrone.

Exemples

L’exemple de code suivant utilise BeginReceive pour recevoir de manière asynchrone une réponse de serveur.

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

Remarques

L’opération asynchrone BeginReceive doit être effectuée en appelant la EndReceive méthode. En règle générale, la méthode est appelée par le requestCallback délégué.

Cette méthode ne bloque pas tant que l’opération n’est pas terminée. Pour bloquer jusqu’à ce que l’opération soit terminée, utilisez la Receive méthode.

Pour plus d’informations sur l’utilisation du modèle de programmation asynchrone, consultez Appel asynchrone de méthodes synchrones.

S’applique à