UdpClient.EndReceive(IAsyncResult, IPEndPoint) Metod

Definition

Namnområde:
System.Net.Sockets
Sammansättning:
System.dll
Sammansättning:
netstandard.dll

Avslutar en väntande asynkron mottagning.

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

Parametrar

asyncResult
IAsyncResult

Ett IAsyncResult objekt som returneras av ett anrop till BeginReceive(AsyncCallback, Object).

remoteEP
IPEndPoint

Den angivna fjärrslutpunkten.

Returer

Byte[]

Om det lyckas, en matris med byte som innehåller datagramdata.

Undantag

ArgumentNullException

asyncResult är null.

ArgumentException

asyncResult returnerades inte av ett anrop till BeginReceive(AsyncCallback, Object) metoden.

InvalidOperationException

EndReceive(IAsyncResult, IPEndPoint) anropades tidigare för den asynkrona läsningen.

SocketException

Ett fel uppstod vid försök att komma åt den underliggande Socket.

ObjectDisposedException

Socket Underliggande har stängts.

Exempel

I följande kodexempel används BeginSend för att slutföra en asynkron mottagning av ett serversvar.

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

Kommentarer

Den här metoden blockerar tills åtgärden har slutförts.

Använd metoden för Receive att utföra den här åtgärden synkront.

Gäller för