UdpClient.BeginSend Méthode

Référence

Définition

Espace de noms:: System.Net.Sockets

Assembly:: System.Net.Sockets.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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

IAsyncResult

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

IAsyncResult

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

IAsyncResult

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 à

Partager via

UdpClient.BeginSend Méthode

Définition

Surcharges

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

Paramètres

Retours

Exemples

Remarques

S’applique à

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

Paramètres

Retours

Exemples

Remarques

S’applique à

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

Paramètres

Retours

Exemples

Remarques

S’applique à

Ressources supplémentaires