UdpClient.EndReceive(IAsyncResult, IPEndPoint) Méthode

Définition

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

Met fin à une réception asynchrone en attente.

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()

Paramètres

asyncResult
IAsyncResult

Objet IAsyncResult retourné par un appel à BeginReceive(AsyncCallback, Object).

remoteEP
IPEndPoint

Point de terminaison distant spécifié.

Retours

Byte[]

En cas de réussite, tableau d’octets qui contient des données de datagramme.

Exceptions

ArgumentNullException

asyncResult a la valeur null.

ArgumentException

asyncResult n’a pas été retourné par un appel à la BeginReceive(AsyncCallback, Object) méthode.

InvalidOperationException

EndReceive(IAsyncResult, IPEndPoint) a été précédemment appelé pour la lecture asynchrone.

SocketException

Une erreur s’est produite lors de la tentative d’accès au sous-jacent Socket.

ObjectDisposedException

Le sous-jacent Socket a été fermé.

Exemples

L’exemple de code suivant utilise BeginSend pour terminer une réception asynchrone d’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

Cette méthode se bloque jusqu’à ce que l’opération soit terminée.

Pour effectuer cette opération de façon synchrone, utilisez la Receive méthode.

S’applique à