UdpClient.BeginReceive(AsyncCallback, Object) Yöntem

Tanım

Ad Alanı:

System.Net.Sockets

Bütünleştirilmiş Kod:

System.Net.Sockets.dll

Kaynak:

UDPClient.cs

Uzak konaktan zaman uyumsuz olarak bir veri birimi alır.

public:
 IAsyncResult ^ BeginReceive(AsyncCallback ^ requestCallback, System::Object ^ state);

public IAsyncResult BeginReceive (AsyncCallback? requestCallback, object? state);

member this.BeginReceive : AsyncCallback * obj -> IAsyncResult

Public Function BeginReceive (requestCallback As AsyncCallback, state As Object) As IAsyncResult

Parametreler

requestCallback

AsyncCallback

AsyncCallback İşlem tamamlandığında çağrılacak yönteme başvuran bir temsilci.

state

Object

Alma işlemi hakkında bilgi içeren kullanıcı tanımlı bir nesne. İşlem tamamlandığında bu nesne temsilciye requestCallback geçirilir.

Döndürülenler

IAsyncResult

IAsyncResult Zaman uyumsuz alma işlemine başvuran bir nesne.

Örnekler

Aşağıdaki kod örneği, bir sunucu yanıtını zaman uyumsuz olarak almak için kullanır BeginReceive .

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

Zaman uyumsuz BeginReceive işlem yöntemi çağrılarak EndReceive tamamlanmalıdır. Genellikle yöntemi temsilci tarafından çağrılır requestCallback .

İşlem tamamlanana kadar bu yöntem engellemez. İşlem tamamlanana kadar engellemek için yöntemini kullanın Receive .

Zaman uyumsuz programlama modelini kullanma hakkında ayrıntılı bilgi için bkz. Zaman Uyumlu Yöntemleri Zaman Uyumsuz Olarak Çağırma.