Partager via


UdpClient.BeginSend Méthode

Définition

Envoie un datagramme à un hôte distant de manière asynchrone.

Surcharges

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

Envoie un datagramme à une destination de manière asynchrone. La destination est spécifiée par le nom d'hôte et le numéro de port.

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

Envoie un datagramme à une destination de manière asynchrone. La destination est spécifiée par un EndPoint.

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

Envoie un datagramme à un hôte distant de manière asynchrone. La destination a été spécifiée précédemment par un appel à Connect.

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

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

Envoie un datagramme à une destination de manière asynchrone. La destination est spécifiée par le nom d'hôte et le numéro de port.

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

Paramètres

datagram
Byte[]

Tableau Byte qui contient les données à envoyer.

bytes
Int32

Le nombre d’octets à envoyer.

hostname
String

Hôte de destination.

port
Int32

Numéro du port de destination.

requestCallback
AsyncCallback

Délégué AsyncCallback qui fait référence à la méthode à appeler quand l'opération est terminée.

state
Object

Objet défini par l'utilisateur qui comporte des informations sur l'opération d'envoi. Cet objet est passé au délégué requestCallback quand l'opération est terminée.

Retours

Objet IAsyncResult qui fait référence à l'envoi asynchrone.

Exemples

L’exemple de code suivant utilise BeginSend pour envoyer de manière asynchrone une demande de serveur.

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

Remarques

L’opération asynchrone BeginSend doit être effectuée en appelant la EndSend méthode . En règle générale, la méthode est appelée par le requestCallback délégué.

Cette méthode ne se bloque pas tant que l’opération n’est pas terminée. Pour bloquer jusqu’à ce que l’opération soit terminée, utilisez l’une Send des surcharges de méthode.

Pour plus d’informations sur l’utilisation du modèle de programmation asynchrone, consultez Appel asynchrone de méthodes synchrones.

S’applique à

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

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

Envoie un datagramme à une destination de manière asynchrone. La destination est spécifiée par un EndPoint.

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

Paramètres

datagram
Byte[]

Tableau Byte qui contient les données à envoyer.

bytes
Int32

Le nombre d’octets à envoyer.

endPoint
IPEndPoint

EndPoint qui représente la destination des données.

requestCallback
AsyncCallback

Délégué AsyncCallback qui fait référence à la méthode à appeler quand l'opération est terminée.

state
Object

Objet défini par l'utilisateur qui comporte des informations sur l'opération d'envoi. Cet objet est passé au délégué requestCallback quand l'opération est terminée.

Retours

Objet IAsyncResult qui fait référence à l'envoi asynchrone.

Exemples

L’exemple de code suivant utilise BeginSend pour envoyer de manière asynchrone une demande de serveur.

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

Remarques

L’opération asynchrone BeginSend doit être effectuée en appelant la EndSend méthode . En règle générale, la méthode est appelée par le requestCallback délégué.

Cette méthode ne se bloque pas tant que l’opération n’est pas terminée. Pour bloquer jusqu’à ce que l’opération soit terminée, utilisez l’une Send des surcharges de méthode.

Pour plus d’informations sur l’utilisation du modèle de programmation asynchrone, consultez Appel asynchrone de méthodes synchrones.

S’applique à

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

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

Envoie un datagramme à un hôte distant de manière asynchrone. La destination a été spécifiée précédemment par un appel à 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

Paramètres

datagram
Byte[]

Tableau Byte qui contient les données à envoyer.

bytes
Int32

Le nombre d’octets à envoyer.

requestCallback
AsyncCallback

Délégué AsyncCallback qui fait référence à la méthode à appeler quand l'opération est terminée.

state
Object

Objet défini par l'utilisateur qui comporte des informations sur l'opération d'envoi. Cet objet est passé au délégué requestCallback quand l'opération est terminée.

Retours

Objet IAsyncResult qui fait référence à l'envoi asynchrone.

Exemples

L’exemple de code suivant utilise BeginSend pour envoyer de manière asynchrone une demande de serveur.

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

Remarques

L’opération asynchrone BeginSend doit être effectuée en appelant la EndSend méthode . En règle générale, la méthode est appelée par le requestCallback délégué.

Cette méthode ne se bloque pas tant que l’opération n’est pas terminée. Pour bloquer jusqu’à ce que l’opération soit terminée, utilisez l’une Send des surcharges de méthode.

Pour plus d’informations sur l’utilisation du modèle de programmation asynchrone, consultez Appel asynchrone de méthodes synchrones.

S’applique à