Condividi tramite

UdpClient.BeginSend Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System.Net.Sockets
Assembly:
System.Net.Sockets.dll
Assembly:
System.dll
Assembly:
netstandard.dll

Invia un datagramma a un host remoto in modalità asincrona.

Overload

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

Invia un datagramma a una destinazione in modalità asincrona. La destinazione è specificata mediante il nome dell'host e il numero di porta.
BeginSend(Byte[], Int32, IPEndPoint, AsyncCallback, Object)

Invia un datagramma a una destinazione in modalità asincrona. La destinazione è specificata da una classe EndPoint.
BeginSend(Byte[], Int32, AsyncCallback, Object)

Invia un datagramma a un host remoto in modalità asincrona. La destinazione è stata specificata precedentemente da una chiamata al metodo Connect.

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

Origine:
UDPClient.cs
Origine:
UDPClient.cs
Origine:
UDPClient.cs

Invia un datagramma a una destinazione in modalità asincrona. La destinazione è specificata mediante il nome dell'host e il numero di porta.

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

Parametri

datagram
Byte[]

Matrice Byte contenente i dati da inviare.

bytes
Int32

Numero di byte da inviare.

hostname
String

Host di destinazione.

port
Int32

Numero della porta di destinazione.

requestCallback
AsyncCallback

Delegato AsyncCallback cui fa riferimento il metodo da richiamare al completamento dell'operazione.

state
Object

Oggetto definito dall'utente contenente informazioni sull'operazione di invio. Questo oggetto viene passato al delegato requestCallback al completamento dell'operazione.

Restituisce

IAsyncResult

Oggetto IAsyncResult che fa riferimento all'invio asincrono.

Esempio

Nell'esempio di codice seguente viene BeginSend usato per inviare in modo asincrono una richiesta server.

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

Commenti

L'operazione asincrona BeginSend deve essere completata chiamando il EndSend metodo . In genere, il metodo viene richiamato dal requestCallback delegato.

Questo metodo non viene bloccato fino al completamento dell'operazione. Per bloccare fino al completamento dell'operazione, usare uno degli overload del Send metodo.

Per informazioni dettagliate sull'uso del modello di programmazione asincrona, vedere Chiamata asincrona di metodi sincroni.

Si applica a

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

Origine:
UDPClient.cs
Origine:
UDPClient.cs
Origine:
UDPClient.cs

Invia un datagramma a una destinazione in modalità asincrona. La destinazione è specificata da una classe 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

Parametri

datagram
Byte[]

Matrice Byte contenente i dati da inviare.

bytes
Int32

Numero di byte da inviare.

endPoint
IPEndPoint

Classe EndPoint che rappresenta la destinazione dei dati.

requestCallback
AsyncCallback

Delegato AsyncCallback cui fa riferimento il metodo da richiamare al completamento dell'operazione.

state
Object

Oggetto definito dall'utente contenente informazioni sull'operazione di invio. Questo oggetto viene passato al delegato requestCallback al completamento dell'operazione.

Restituisce

IAsyncResult

Oggetto IAsyncResult che fa riferimento all'invio asincrono.

Esempio

Nell'esempio di codice seguente viene BeginSend usato per inviare in modo asincrono una richiesta server.

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

Commenti

L'operazione asincrona BeginSend deve essere completata chiamando il EndSend metodo . In genere, il metodo viene richiamato dal requestCallback delegato.

Questo metodo non viene bloccato fino al completamento dell'operazione. Per bloccare fino al completamento dell'operazione, usare uno degli overload del Send metodo.

Per informazioni dettagliate sull'uso del modello di programmazione asincrona, vedere Chiamata asincrona di metodi sincroni.

Si applica a

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

Origine:
UDPClient.cs
Origine:
UDPClient.cs
Origine:
UDPClient.cs

Invia un datagramma a un host remoto in modalità asincrona. La destinazione è stata specificata precedentemente da una chiamata al metodo 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

Parametri

datagram
Byte[]

Matrice Byte contenente i dati da inviare.

bytes
Int32

Numero di byte da inviare.

requestCallback
AsyncCallback

Delegato AsyncCallback cui fa riferimento il metodo da richiamare al completamento dell'operazione.

state
Object

Oggetto definito dall'utente contenente informazioni sull'operazione di invio. Questo oggetto viene passato al delegato requestCallback al completamento dell'operazione.

Restituisce

IAsyncResult

Oggetto IAsyncResult che fa riferimento all'invio asincrono.

Esempio

Nell'esempio di codice seguente viene BeginSend usato per inviare in modo asincrono una richiesta server.

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

Commenti

L'operazione asincrona BeginSend deve essere completata chiamando il EndSend metodo . In genere, il metodo viene richiamato dal requestCallback delegato.

Questo metodo non viene bloccato fino al completamento dell'operazione. Per bloccare fino al completamento dell'operazione, usare uno degli overload del Send metodo.

Per informazioni dettagliate sull'uso del modello di programmazione asincrona, vedere Chiamata asincrona di metodi sincroni.

Si applica a