UdpClient.BeginReceive(AsyncCallback, Object) Method (System.Net.Sockets)

link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

Parameters

A user-defined object that contains information about the receive operation. This object is passed to the requestCallback delegate when the operation is complete.

Returns

Examples

The following code example uses BeginReceive to asynchronously receive a server response.


   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);
    
     Remarks
    
    
     The asynchronous
     
      BeginReceive
     
     operation must be completed by calling the
     
      EndReceive
     
     method. Typically, the method is invoked by the
     
      requestCallback
     
     delegate.
    
    
     This method does not block until the operation is complete. To block until the operation is complete, use the
     
      Receive
     
     method.
    
    
     For detailed information about using the asynchronous programming model, see
     
      Calling Synchronous Methods Asynchronously
     
     .
    
    Coming soon: Throughout 2024 we will be phasing out GitHub Issues as the feedback mechanism for content and replacing it with a new feedback system. For more information see:
    
     https://aka.ms/ContentUserFeedback
    
    .
    
    
    
     Submit and view feedback for
    
    
     This product