Comparteix a través de

UdpClient.BeginSend Método

  • Referencia

Definición

Espacio de nombres:
System.Net.Sockets
Ensamblado:
System.Net.Sockets.dll
Ensamblado:
System.dll
Ensamblado:
netstandard.dll

Envía un datagrama a un host remoto de forma asincrónica.

Sobrecargas

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

Envía un datagrama a un destino de forma asincrónica. El nombre de host y el número de puerto especifican el destino.
BeginSend(Byte[], Int32, IPEndPoint, AsyncCallback, Object)

Envía un datagrama a un destino de forma asincrónica. EndPoint especifica el destino.
BeginSend(Byte[], Int32, AsyncCallback, Object)

Envía un datagrama a un host remoto de forma asincrónica. El destino se especificó anteriormente mediante una llamada a Connect.

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

Source:
UDPClient.cs
Source:
UDPClient.cs
Source:
UDPClient.cs

Envía un datagrama a un destino de forma asincrónica. El nombre de host y el número de puerto especifican el destino.

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

Parámetros

datagram
Byte[]

Matriz Byte que contiene los datos que se desea enviar.

bytes
Int32

Número de bytes para enviar.

hostname
String

Host de destino.

port
Int32

Número de puerto de destino.

requestCallback
AsyncCallback

Delegado de AsyncCallback que hace referencia al método que se invocará cuando la operación se complete.

state
Object

Objeto definido por el usuario que contiene información sobre la operación. Este objeto se pasa al delegado de requestCallback cuando la operación se completa.

Devoluciones

IAsyncResult

Objeto IAsyncResult que hace referencia al envío asincrónico.

Ejemplos

En el ejemplo de código siguiente se usa BeginSend para enviar de forma asincrónica una solicitud de servidor.

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

Comentarios

La operación asincrónica BeginSend debe completarse llamando al EndSend método . Normalmente, el delegado invoca el requestCallback método .

Este método no se bloquea hasta que se complete la operación. Para bloquear hasta que se complete la operación, use una de las sobrecargas del Send método .

Para obtener información detallada sobre el uso del modelo de programación asincrónica, vea Llamar a métodos sincrónicos de forma asincrónica.

Se aplica a

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

Source:
UDPClient.cs
Source:
UDPClient.cs
Source:
UDPClient.cs

Envía un datagrama a un destino de forma asincrónica. EndPoint especifica el destino.

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

Parámetros

datagram
Byte[]

Matriz Byte que contiene los datos que se desea enviar.

bytes
Int32

Número de bytes para enviar.

endPoint
IPEndPoint

EndPoint que representa el destino de los datos.

requestCallback
AsyncCallback

Delegado de AsyncCallback que hace referencia al método que se invocará cuando la operación se complete.

state
Object

Objeto definido por el usuario que contiene información sobre la operación. Este objeto se pasa al delegado de requestCallback cuando la operación se completa.

Devoluciones

IAsyncResult

Objeto IAsyncResult que hace referencia al envío asincrónico.

Ejemplos

En el ejemplo de código siguiente se usa BeginSend para enviar de forma asincrónica una solicitud de servidor.

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

Comentarios

La operación asincrónica BeginSend debe completarse llamando al EndSend método . Normalmente, el delegado invoca el requestCallback método .

Este método no se bloquea hasta que se complete la operación. Para bloquear hasta que se complete la operación, use una de las sobrecargas del Send método .

Para obtener información detallada sobre el uso del modelo de programación asincrónica, vea Llamar a métodos sincrónicos de forma asincrónica.

Se aplica a

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

Source:
UDPClient.cs
Source:
UDPClient.cs
Source:
UDPClient.cs

Envía un datagrama a un host remoto de forma asincrónica. El destino se especificó anteriormente mediante una llamada a Connect.

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

Parámetros

datagram
Byte[]

Matriz Byte que contiene los datos que se desea enviar.

bytes
Int32

Número de bytes para enviar.

requestCallback
AsyncCallback

Delegado de AsyncCallback que hace referencia al método que se invocará cuando la operación se complete.

state
Object

Objeto definido por el usuario que contiene información sobre la operación. Este objeto se pasa al delegado de requestCallback cuando la operación se completa.

Devoluciones

IAsyncResult

Objeto IAsyncResult que hace referencia al envío asincrónico.

Ejemplos

En el ejemplo de código siguiente se usa BeginSend para enviar de forma asincrónica una solicitud de servidor.

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

Comentarios

La operación asincrónica BeginSend debe completarse llamando al EndSend método . Normalmente, el delegado invoca el requestCallback método .

Este método no se bloquea hasta que se completa la operación. Para bloquear hasta que se complete la operación, use una de las sobrecargas del Send método .

Para obtener información detallada sobre el uso del modelo de programación asincrónica, vea Llamar a métodos sincrónicos de forma asincrónica.

Se aplica a