UdpClient.EndReceive(IAsyncResult, IPEndPoint) Methode

Definitie

Naamruimte:
System.Net.Sockets
Assembly:
System.dll
Assembly:
netstandard.dll

Hiermee wordt een asynchrone ontvangst beëindigd.

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

Parameters

asyncResult
IAsyncResult

Een IAsyncResult object dat wordt geretourneerd door een aanroep naar BeginReceive(AsyncCallback, Object).

remoteEP
IPEndPoint

Het opgegeven externe eindpunt.

Retouren

Byte[]

Als dit lukt, is er een matrix van bytes die datagramgegevens bevat.

Uitzonderingen

ArgumentNullException

asyncResult is null.

ArgumentException

asyncResult is niet geretourneerd door een aanroep naar de BeginReceive(AsyncCallback, Object) methode.

InvalidOperationException

EndReceive(IAsyncResult, IPEndPoint) werd eerder aangeroepen voor de asynchrone leesbewerking.

SocketException

Er is een fout opgetreden bij een poging om toegang te krijgen tot de onderliggende Socketgegevens.

ObjectDisposedException

De onderliggende Socket waarde is gesloten.

Voorbeelden

In het volgende codevoorbeeld wordt een BeginSend asynchrone ontvangst van een serverantwoord voltooid.

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

Opmerkingen

Deze methode blokkeert totdat de bewerking is voltooid.

Gebruik de Receive methode om deze bewerking synchroon uit te voeren.

Van toepassing op