UdpClient.BeginSend Methode

Referenz

Definition

Namespace:: System.Net.Sockets

Assembly:: System.Net.Sockets.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Sendet asynchron ein Datagramm an einen Remotehost.

Überlädt

BeginSend(Byte[], Int32, String, Int32, AsyncCallback, Object)	Sendet asynchron ein Datagramm an ein Ziel. Das Ziel wird durch einen Hostnamen und eine Anschlussnummer angegeben.
BeginSend(Byte[], Int32, IPEndPoint, AsyncCallback, Object)	Sendet asynchron ein Datagramm an ein Ziel. Das Ziel wird durch einen EndPointangegeben.
BeginSend(Byte[], Int32, AsyncCallback, Object)	Sendet asynchron ein Datagramm an einen Remotehost. Das Ziel wurde zuvor durch Aufruf von Connect angegeben.

BeginSend(Byte[], Int32, String, Int32, AsyncCallback, Object)

Quelle:: UDPClient.cs

Quelle:: UDPClient.cs

Quelle:: UDPClient.cs

Sendet asynchron ein Datagramm an ein Ziel. Das Ziel wird durch einen Hostnamen und eine Anschlussnummer angegeben.

public:
 IAsyncResult ^ BeginSend(cli::array <System::Byte> ^ datagram, int bytes, System::String ^ hostname, int port, AsyncCallback ^ requestCallback, System::Object ^ state);

public IAsyncResult BeginSend (byte[] datagram, int bytes, string? hostname, int port, AsyncCallback? requestCallback, object? state);

public IAsyncResult BeginSend (byte[] datagram, int bytes, string hostname, int port, AsyncCallback requestCallback, object state);

member this.BeginSend : byte[] * int * string * int * AsyncCallback * obj -> IAsyncResult

Public Function BeginSend (datagram As Byte(), bytes As Integer, hostname As String, port As Integer, requestCallback As AsyncCallback, state As Object) As IAsyncResult

Parameter

datagram: Byte[]

Ein Byte-Array, das die zu sendenden Daten enthält.

bytes: Int32

Die Anzahl von Bytes, die gesendet werden sollen.

hostname: String

Der Zielhost.

port: Int32

Die Zielanschlussnummer.

requestCallback: AsyncCallback

Ein AsyncCallback-Delegat, der auf die Methode verweist, die bei Abschluss des Vorgangs aufgerufen werden soll.

state: Object

Ein benutzerdefiniertes Objekt, das Informationen zum Sendevorgang enthält. Dieses Objekt wird bei Abschluss des Vorgangs an den requestCallback-Delegaten übergeben.

Gibt zurück

IAsyncResult

Ein IAsyncResult, das auf den asynchronen Sendevorgang verweist.

Beispiele

Im folgenden Codebeispiel wird verwendet BeginSend , um eine Serveranforderung asynchron zu senden.

public:
    static bool isMessageSent;

    static void SendCallback(IAsyncResult^ asyncResult)
    {
        UdpClient^ udpClient = (UdpClient^)asyncResult->AsyncState;

        Console::WriteLine("number of bytes sent: {0}",
            udpClient->EndSend(asyncResult));
        isMessageSent = true;
    }

public static bool messageSent = false;

public static void SendCallback(IAsyncResult ar)
{
    UdpClient u = (UdpClient)ar.AsyncState;

    Console.WriteLine($"number of bytes sent: {u.EndSend(ar)}");
    messageSent = true;
}

public:
    static void SendMessage3(String^ server, String^ message)
    {
        // create the udp socket
        UdpClient^ udpClient = gcnew UdpClient();

        array<Byte>^ sendBytes = Encoding::ASCII->GetBytes(message);

        // send the message
        // the destination is defined by the server name and port
        udpClient->BeginSend(sendBytes, sendBytes->Length, server, listenPort,
            gcnew AsyncCallback(SendCallback), udpClient);

        // Do some work while we wait for the send to complete. For
        // this example, we'll just sleep
        while (!isMessageSent)
        {
            Thread::Sleep(100);
        }
    }

static void SendMessage3(string server, string message)
{
    // create the udp socket
    UdpClient u = new UdpClient();

    byte[] sendBytes = Encoding.ASCII.GetBytes(message);

    // send the message
    // the destination is defined by the server name and port
    u.BeginSend(sendBytes, sendBytes.Length, server, s_listenPort, new AsyncCallback(SendCallback), u);

    // Do some work while we wait for the send to complete. For this example, we'll just sleep
    while (!messageSent)
    {
        Thread.Sleep(100);
    }
}

Hinweise

Der asynchrone BeginSend Vorgang muss durch Aufrufen der EndSend -Methode abgeschlossen werden. In der Regel wird die -Methode vom requestCallback Delegaten aufgerufen.

Diese Methode wird erst blockiert, wenn der Vorgang abgeschlossen ist. Um zu blockieren, bis der Vorgang abgeschlossen ist, verwenden Sie eine der Send Methodenüberladungen.

Ausführliche Informationen zur Verwendung des asynchronen Programmiermodells finden Sie unter Asynchrones Aufrufen synchroner Methoden.

Gilt für:

BeginSend(Byte[], Int32, IPEndPoint, AsyncCallback, Object)

Quelle:: UDPClient.cs

Quelle:: UDPClient.cs

Quelle:: UDPClient.cs

Sendet asynchron ein Datagramm an ein Ziel. Das Ziel wird durch einen EndPointangegeben.

public:
 IAsyncResult ^ BeginSend(cli::array <System::Byte> ^ datagram, int bytes, System::Net::IPEndPoint ^ endPoint, AsyncCallback ^ requestCallback, System::Object ^ state);

public IAsyncResult BeginSend (byte[] datagram, int bytes, System.Net.IPEndPoint? endPoint, AsyncCallback? requestCallback, object? state);

public IAsyncResult BeginSend (byte[] datagram, int bytes, System.Net.IPEndPoint endPoint, AsyncCallback requestCallback, object state);

member this.BeginSend : byte[] * int * System.Net.IPEndPoint * AsyncCallback * obj -> IAsyncResult

Public Function BeginSend (datagram As Byte(), bytes As Integer, endPoint As IPEndPoint, requestCallback As AsyncCallback, state As Object) As IAsyncResult

Parameter

datagram: Byte[]

Ein Byte-Array, das die zu sendenden Daten enthält.

bytes: Int32

Die Anzahl von Bytes, die gesendet werden sollen.

endPoint: IPEndPoint

Der EndPoint, der das Ziel der Daten darstellt.

requestCallback: AsyncCallback

Ein AsyncCallback-Delegat, der auf die Methode verweist, die bei Abschluss des Vorgangs aufgerufen werden soll.

state: Object

Ein benutzerdefiniertes Objekt, das Informationen zum Sendevorgang enthält. Dieses Objekt wird bei Abschluss des Vorgangs an den requestCallback-Delegaten übergeben.

Gibt zurück

IAsyncResult

Ein IAsyncResult, das auf den asynchronen Sendevorgang verweist.

Beispiele

Im folgenden Codebeispiel wird verwendet BeginSend , um eine Serveranforderung asynchron zu senden.

public:
    static bool isMessageSent;

    static void SendCallback(IAsyncResult^ asyncResult)
    {
        UdpClient^ udpClient = (UdpClient^)asyncResult->AsyncState;

        Console::WriteLine("number of bytes sent: {0}",
            udpClient->EndSend(asyncResult));
        isMessageSent = true;
    }

public static bool messageSent = false;

public static void SendCallback(IAsyncResult ar)
{
    UdpClient u = (UdpClient)ar.AsyncState;

    Console.WriteLine($"number of bytes sent: {u.EndSend(ar)}");
    messageSent = true;
}

public:
    static void SendMessage2(String^ server, String^ message)
    {
        // create the udp socket
        UdpClient^ udpClient = gcnew UdpClient();
        array<Byte>^ sendBytes = Encoding::ASCII->GetBytes(message);

        // resolve the server name
        IPHostEntry^ resolvedServer = Dns::GetHostEntry(server);

        IPEndPoint^ ipEndPoint =
            gcnew IPEndPoint(resolvedServer->AddressList[0], listenPort);

        // send the message
        // the destination is defined by the IPEndPoint
        udpClient->BeginSend(sendBytes, sendBytes->Length, ipEndPoint,
            gcnew AsyncCallback(SendCallback), udpClient);

        // Do some work while we wait for the send to complete. For
        // this example, we'll just sleep
        while (!isMessageSent)
        {
            Thread::Sleep(100);
        }
    }

static void SendMessage2(string server, string message)
{
    // create the udp socket
    UdpClient u = new UdpClient();
    byte[] sendBytes = Encoding.ASCII.GetBytes(message);

    // resolve the server name
    IPHostEntry heserver = Dns.GetHostEntry(server);

    IPEndPoint e = new IPEndPoint(heserver.AddressList[0], s_listenPort);

    // send the message
    // the destination is defined by the IPEndPoint
    u.BeginSend(sendBytes, sendBytes.Length, e, new AsyncCallback(SendCallback), u);

    // Do some work while we wait for the send to complete. For this example, we'll just sleep
    while (!messageSent)
    {
        Thread.Sleep(100);
    }
}

Hinweise

Der asynchrone BeginSend Vorgang muss durch Aufrufen der EndSend -Methode abgeschlossen werden. In der Regel wird die -Methode vom requestCallback Delegaten aufgerufen.

Diese Methode wird erst blockiert, wenn der Vorgang abgeschlossen ist. Um zu blockieren, bis der Vorgang abgeschlossen ist, verwenden Sie eine der Send Methodenüberladungen.

Ausführliche Informationen zur Verwendung des asynchronen Programmiermodells finden Sie unter Asynchrones Aufrufen synchroner Methoden.

Gilt für:

BeginSend(Byte[], Int32, AsyncCallback, Object)

Quelle:: UDPClient.cs

Quelle:: UDPClient.cs

Quelle:: UDPClient.cs

Sendet asynchron ein Datagramm an einen Remotehost. Das Ziel wurde zuvor durch Aufruf von Connect angegeben.

public:
 IAsyncResult ^ BeginSend(cli::array <System::Byte> ^ datagram, int bytes, AsyncCallback ^ requestCallback, System::Object ^ state);

public IAsyncResult BeginSend (byte[] datagram, int bytes, AsyncCallback? requestCallback, object? state);

public IAsyncResult BeginSend (byte[] datagram, int bytes, AsyncCallback requestCallback, object state);

member this.BeginSend : byte[] * int * AsyncCallback * obj -> IAsyncResult

Public Function BeginSend (datagram As Byte(), bytes As Integer, requestCallback As AsyncCallback, state As Object) As IAsyncResult

Parameter

datagram: Byte[]

Ein Byte-Array, das die zu sendenden Daten enthält.

bytes: Int32

Die Anzahl von Bytes, die gesendet werden sollen.

requestCallback: AsyncCallback

Ein AsyncCallback-Delegat, der auf die Methode verweist, die bei Abschluss des Vorgangs aufgerufen werden soll.

state: Object

Ein benutzerdefiniertes Objekt, das Informationen zum Sendevorgang enthält. Dieses Objekt wird bei Abschluss des Vorgangs an den requestCallback-Delegaten übergeben.

Gibt zurück

IAsyncResult

Ein IAsyncResult, das auf den asynchronen Sendevorgang verweist.

Beispiele

Im folgenden Codebeispiel wird verwendet BeginSend , um eine Serveranforderung asynchron zu senden.

public:
    static bool isMessageSent;

    static void SendCallback(IAsyncResult^ asyncResult)
    {
        UdpClient^ udpClient = (UdpClient^)asyncResult->AsyncState;

        Console::WriteLine("number of bytes sent: {0}",
            udpClient->EndSend(asyncResult));
        isMessageSent = true;
    }

public static bool messageSent = false;

public static void SendCallback(IAsyncResult ar)
{
    UdpClient u = (UdpClient)ar.AsyncState;

    Console.WriteLine($"number of bytes sent: {u.EndSend(ar)}");
    messageSent = true;
}

public:
    static void SendMessage1(String^ server, String^ message)
    {
        // create the udp socket
        UdpClient^ udpClient = gcnew UdpClient();

        udpClient->Connect(server, listenPort);
        array<Byte>^ sendBytes = Encoding::ASCII->GetBytes(message);

        // send the message
        // the destination is defined by the call to .Connect()
        udpClient->BeginSend(sendBytes, sendBytes->Length,
            gcnew AsyncCallback(SendCallback), udpClient);

        // Do some work while we wait for the send to complete. For
        // this example, we'll just sleep
        while (!isMessageSent)
        {
            Thread::Sleep(100);
        }
    }

static void SendMessage1(string server, string message)
{
    // create the udp socket
    UdpClient u = new UdpClient();

    u.Connect(server, s_listenPort);
    byte[] sendBytes = Encoding.ASCII.GetBytes(message);

    // send the message
    // the destination is defined by the call to .Connect()
    u.BeginSend(sendBytes, sendBytes.Length, new AsyncCallback(SendCallback), u);

    // Do some work while we wait for the send to complete. For this example, we'll just sleep
    while (!messageSent)
    {
        Thread.Sleep(100);
    }
}

Hinweise

Der asynchrone BeginSend Vorgang muss durch Aufrufen der EndSend -Methode abgeschlossen werden. In der Regel wird die -Methode vom requestCallback Delegaten aufgerufen.

Diese Methode wird erst blockiert, wenn der Vorgang abgeschlossen ist. Um zu blockieren, bis der Vorgang abgeschlossen ist, verwenden Sie eine der Send Methodenüberladungen.

Ausführliche Informationen zur Verwendung des asynchronen Programmiermodells finden Sie unter Asynchrones Aufrufen synchroner Methoden.

Gilt für:

UdpClient.BeginSend Methode

Definition

Überlädt

BeginSend(Byte[], Int32, String, Int32, AsyncCallback, Object)

Parameter

Gibt zurück

Beispiele

Hinweise

Gilt für:

BeginSend(Byte[], Int32, IPEndPoint, AsyncCallback, Object)

Parameter

Gibt zurück

Beispiele

Hinweise

Gilt für:

BeginSend(Byte[], Int32, AsyncCallback, Object)

Parameter

Gibt zurück

Beispiele

Hinweise

Gilt für:

Feedback

Zusätzliche Ressourcen