UdpClient.EndReceive(IAsyncResult, IPEndPoint) Yöntem

Tanım

Ad Alanı:

System.Net.Sockets

Bütünleştirilmiş Kod:

System.Net.Sockets.dll

Kaynak:

UDPClient.cs

Bekleyen zaman uyumsuz alma işlemini sonlandırır.

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

Parametreler

asyncResult

IAsyncResult

IAsyncResult çağrısı BeginReceive(AsyncCallback, Object)tarafından döndürülen bir nesne.

remoteEP

IPEndPoint

Belirtilen uzak uç nokta.

Döndürülenler

Byte[]

Başarılı olursa, veri birimi verilerini içeren bir bayt dizisi.

Özel durumlar

ArgumentNullException

asyncResult, null değeridir.

ArgumentException

asyncResult yöntemine BeginReceive(AsyncCallback, Object) yapılan bir çağrı tarafından döndürülmedi.

InvalidOperationException

EndReceive(IAsyncResult, IPEndPoint) daha önce zaman uyumsuz okuma için çağrıldı.

SocketException

Temel alınan Socketöğesine erişmeye çalışılırken bir hata oluştu.

ObjectDisposedException

Temel alınan Socket kapatıldı.

Örnekler

Aşağıdaki kod örneği, bir sunucu yanıtının zaman uyumsuz bir alımını tamamlamak için kullanır 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);
    }
}

Açıklamalar

Bu yöntem, işlem tamamlanana kadar engeller.

Bu işlemi zaman uyumlu olarak gerçekleştirmek için yöntemini kullanın Receive .