UdpClient.BeginSend Método
Definição
Envia um datagrama para um host remoto de forma assíncrona.Sends a datagram to a remote host asynchronously.
Sobrecargas
| BeginSend(Byte[], Int32, String, Int32, AsyncCallback, Object) |
Envia um datagrama para um destino de forma assíncrona.Sends a datagram to a destination asynchronously. O destino é especificado pelo nome do host e número da porta.The destination is specified by the host name and port number. |
| BeginSend(Byte[], Int32, AsyncCallback, Object) |
Envia um datagrama para um host remoto de forma assíncrona.Sends a datagram to a remote host asynchronously. O destino foi especificado anteriormente por uma chamada para Connect.The destination was specified previously by a call to Connect. |
| BeginSend(Byte[], Int32, IPEndPoint, AsyncCallback, Object) |
Envia um datagrama para um destino de forma assíncrona.Sends a datagram to a destination asynchronously. O destino é especificado por um EndPoint.The destination is specified by a EndPoint. |
BeginSend(Byte[], Int32, String, Int32, AsyncCallback, Object)
Envia um datagrama para um destino de forma assíncrona.Sends a datagram to a destination asynchronously. O destino é especificado pelo nome do host e número da porta.The destination is specified by the host name and port number.
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[]
Uma matriz Byte que contém os dados a serem enviados.A Byte array that contains the data to be sent.
- bytes
- Int32
O número de bytes a serem enviados.The number of bytes to send.
- hostname
- String
O host de destino.The destination host.
- port
- Int32
O número da porta de destino.The destination port number.
- requestCallback
- AsyncCallback
Um delegado AsyncCallback que faz referência ao método a ser invocado quando a operação é concluída.An AsyncCallback delegate that references the method to invoke when the operation is complete.
- state
- Object
Um objeto definido pelo usuário que contém informações sobre a operação de envio.A user-defined object that contains information about the send operation. Esse objeto é passado para o delegado requestCallback quando a operação é concluída.This object is passed to the requestCallback delegate when the operation is complete.
Retornos
Um objeto IAsyncResult que faz referência ao envio assíncrono.An IAsyncResult object that references the asynchronous send.
Exemplos
O exemplo de código a seguir usa BeginSend para enviar uma solicitação de servidor de forma assíncrona.The following code example uses BeginSend to asynchronously send a server request.
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);
}
}
Comentários
A operação assíncrona BeginSend deve ser concluída chamando o EndSend método.The asynchronous BeginSend operation must be completed by calling the EndSend method. Normalmente, o método é invocado pelo requestCallback delegado.Typically, the method is invoked by the requestCallback delegate.
Este método não é bloqueado até que a operação seja concluída.This method does not block until the operation is complete. Para bloquear até que a operação seja concluída, use uma das Send sobrecargas de método.To block until the operation is complete, use one of the Send method overloads.
Para obter informações detalhadas sobre como usar o modelo de programação assíncrona, consulte chamando métodos síncronos de formaassíncrona.For detailed information about using the asynchronous programming model, see Calling Synchronous Methods Asynchronously.
Aplica-se a
BeginSend(Byte[], Int32, AsyncCallback, Object)
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[]
Uma matriz Byte que contém os dados a serem enviados.A Byte array that contains the data to be sent.
- bytes
- Int32
O número de bytes a serem enviados.The number of bytes to send.
- requestCallback
- AsyncCallback
Um delegado AsyncCallback que faz referência ao método a ser invocado quando a operação é concluída.An AsyncCallback delegate that references the method to invoke when the operation is complete.
- state
- Object
Um objeto definido pelo usuário que contém informações sobre a operação de envio.A user-defined object that contains information about the send operation. Esse objeto é passado para o delegado requestCallback quando a operação é concluída.This object is passed to the requestCallback delegate when the operation is complete.
Retornos
Um objeto IAsyncResult que faz referência ao envio assíncrono.An IAsyncResult object that references the asynchronous send.
Exemplos
O exemplo de código a seguir usa BeginSend para enviar uma solicitação de servidor de forma assíncrona.The following code example uses BeginSend to asynchronously send a server request.
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);
}
}
Comentários
A operação assíncrona BeginSend deve ser concluída chamando o EndSend método.The asynchronous BeginSend operation must be completed by calling the EndSend method. Normalmente, o método é invocado pelo requestCallback delegado.Typically, the method is invoked by the requestCallback delegate.
Esse método não é bloqueado até que a operação seja concluída.This method does not block until the operation completes. Para bloquear até que a operação seja concluída, use uma das Send sobrecargas de método.To block until the operation is complete, use one of the Send method overloads.
Para obter informações detalhadas sobre como usar o modelo de programação assíncrona, consulte chamando métodos síncronos de formaassíncrona.For detailed information about using the asynchronous programming model, see Calling Synchronous Methods Asynchronously.
Aplica-se a
BeginSend(Byte[], Int32, IPEndPoint, AsyncCallback, Object)
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[]
Uma matriz Byte que contém os dados a serem enviados.A Byte array that contains the data to be sent.
- bytes
- Int32
O número de bytes a serem enviados.The number of bytes to send.
- endPoint
- IPEndPoint
O EndPoint que representa o destino dos dados.The EndPoint that represents the destination for the data.
- requestCallback
- AsyncCallback
Um delegado AsyncCallback que faz referência ao método a ser invocado quando a operação é concluída.An AsyncCallback delegate that references the method to invoke when the operation is complete.
- state
- Object
Um objeto definido pelo usuário que contém informações sobre a operação de envio.A user-defined object that contains information about the send operation. Esse objeto é passado para o delegado requestCallback quando a operação é concluída.This object is passed to the requestCallback delegate when the operation is complete.
Retornos
Um objeto IAsyncResult que faz referência ao envio assíncrono.An IAsyncResult object that references the asynchronous send.
Exemplos
O exemplo de código a seguir usa BeginSend para enviar uma solicitação de servidor de forma assíncrona.The following code example uses BeginSend to asynchronously send a server request.
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);
}
}
Comentários
A operação assíncrona BeginSend deve ser concluída chamando o EndSend método.The asynchronous BeginSend operation must be completed by calling the EndSend method. Normalmente, o método é invocado pelo requestCallback delegado.Typically, the method is invoked by the requestCallback delegate.
Este método não é bloqueado até que a operação seja concluída.This method does not block until the operation is complete. Para bloquear até que a operação seja concluída, use uma das Send sobrecargas de método.To block until the operation is complete, use one of the Send method overloads.
Para obter informações detalhadas sobre como usar o modelo de programação assíncrona, consulte chamando métodos síncronos de formaassíncrona.For detailed information about using the asynchronous programming model, see Calling Synchronous Methods Asynchronously.