UdpClient.EndReceive(IAsyncResult, IPEndPoint) Metoda

Definicja

Przestrzeń nazw:

System.Net.Sockets

Zestaw:

System.Net.Sockets.dll

Źródło:

UDPClient.cs

Kończy oczekujące asynchroniczne odbieranie.

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

Parametry

asyncResult

IAsyncResult

IAsyncResult Obiekt zwrócony przez wywołanie metody BeginReceive(AsyncCallback, Object).

remoteEP

IPEndPoint

Określony zdalny punkt końcowy.

Zwraca

Byte[]

W przypadku powodzenia tablica bajtów zawierająca dane datagramu.

Wyjątki

ArgumentNullException

asyncResult to null.

ArgumentException

asyncResult element nie został zwrócony przez wywołanie BeginReceive(AsyncCallback, Object) metody .

InvalidOperationException

EndReceive(IAsyncResult, IPEndPoint) wcześniej był wywoływany dla odczytu asynchronicznego.

SocketException

Wystąpił błąd podczas próby uzyskania dostępu do bazowego Socketelementu .

ObjectDisposedException

Bazowy Socket został zamknięty.

Przykłady

Poniższy przykład kodu używa BeginSend metody do ukończenia 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

Ta metoda blokuje działanie do momentu ukończenia operacji.

Aby wykonać tę operację synchronicznie, użyj Receive metody .