UdpClient.EndReceive(IAsyncResult, IPEndPoint) Méthode

Référence

Définition

Espace de noms:: System.Net.Sockets

Assembly:: System.Net.Sockets.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Source:: UDPClient.cs

Source:: UDPClient.cs

Source:: UDPClient.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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

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, un tableau d’octets qui contient les données du datagramme.

Exceptions

ArgumentNullException

asyncResult a la valeur null.

ArgumentException

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

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 Socket sous-jacent.

ObjectDisposedException

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

Exemples

L’exemple de code suivant utilise BeginSend pour effectuer une réception asynchrone d’une réponse de serveur.

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

Remarques

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

Pour effectuer cette opération de manière synchrone, utilisez la Receive méthode .

S’applique à

Partager via