UdpClient.EndReceive(IAsyncResult, IPEndPoint) Метод

Определение

Пространство имен:

System.Net.Sockets

Сборка:

System.Net.Sockets.dll

Исходный код:

UDPClient.cs

Завершает отложенный асинхронный прием.

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

Параметры

asyncResult

IAsyncResult

Объект IAsyncResult, возвращаемый при вызове объекта BeginReceive(AsyncCallback, Object).

remoteEP

IPEndPoint

Заданная удаленная конечная точка.

Возвращаемое значение

Byte[]

В случае успешного выполнения массив байтов, который содержит данные датаграммы.

Исключения

ArgumentNullException

asyncResult имеет значение null.

ArgumentException

Параметр asyncResult не был возвращен вызовом метода BeginReceive(AsyncCallback, Object).

InvalidOperationException

Метод EndReceive(IAsyncResult, IPEndPoint) был ранее вызван для асинхронного чтения.

SocketException

Произошла ошибка при попытке доступа к основному объекту Socket.

ObjectDisposedException

Основной объект Socket закрыт.

Примеры

В следующем примере кода используется BeginSend для завершения асинхронного получения ответа сервера.

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

Комментарии

Этот метод блокируется до завершения операции.

Чтобы выполнить эту операцию синхронно, используйте Receive метод .