UdpClient.BeginSend Method
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Sends a datagram to a remote host asynchronously.
Overloads
BeginSend(Byte[], Int32, String, Int32, AsyncCallback, Object) |
Sends a datagram to a destination asynchronously. The destination is specified by the host name and port number. |
BeginSend(Byte[], Int32, IPEndPoint, AsyncCallback, Object) |
Sends a datagram to a destination asynchronously. The destination is specified by a EndPoint. |
BeginSend(Byte[], Int32, AsyncCallback, Object) |
Sends a datagram to a remote host asynchronously. The destination was specified previously by a call to Connect. |
BeginSend(Byte[], Int32, String, Int32, AsyncCallback, Object)
- Source:
- UDPClient.cs
- Source:
- UDPClient.cs
- Source:
- UDPClient.cs
Sends a datagram to a destination asynchronously. 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
Parameters
- bytes
- Int32
The number of bytes to send.
- hostname
- String
The destination host.
- port
- Int32
The destination port number.
- requestCallback
- AsyncCallback
An AsyncCallback delegate that references the method to invoke when the operation is complete.
- state
- Object
A user-defined object that contains information about the send operation. This object is passed to the requestCallback
delegate when the operation is complete.
Returns
An IAsyncResult object that references the asynchronous send.
Examples
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);
}
}
Remarks
The asynchronous BeginSend operation must be completed by calling the EndSend method. Typically, the method is invoked by the requestCallback
delegate.
This method does not block until the operation is complete. To block until the operation is complete, use one of the Send method overloads.
For detailed information about using the asynchronous programming model, see Calling Synchronous Methods Asynchronously.
Applies to
BeginSend(Byte[], Int32, IPEndPoint, AsyncCallback, Object)
- Source:
- UDPClient.cs
- Source:
- UDPClient.cs
- Source:
- UDPClient.cs
Sends a datagram to a destination asynchronously. The destination is specified by a 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
Parameters
- bytes
- Int32
The number of bytes to send.
- endPoint
- IPEndPoint
The EndPoint that represents the destination for the data.
- requestCallback
- AsyncCallback
An AsyncCallback delegate that references the method to invoke when the operation is complete.
- state
- Object
A user-defined object that contains information about the send operation. This object is passed to the requestCallback
delegate when the operation is complete.
Returns
An IAsyncResult object that references the asynchronous send.
Examples
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);
}
}
Remarks
The asynchronous BeginSend operation must be completed by calling the EndSend method. Typically, the method is invoked by the requestCallback
delegate.
This method does not block until the operation is complete. To block until the operation is complete, use one of the Send method overloads.
For detailed information about using the asynchronous programming model, see Calling Synchronous Methods Asynchronously.
Applies to
BeginSend(Byte[], Int32, AsyncCallback, Object)
- Source:
- UDPClient.cs
- Source:
- UDPClient.cs
- Source:
- UDPClient.cs
Sends a datagram to a remote host asynchronously. The destination was specified previously by a call to 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
Parameters
- bytes
- Int32
The number of bytes to send.
- requestCallback
- AsyncCallback
An AsyncCallback delegate that references the method to invoke when the operation is complete.
- state
- Object
A user-defined object that contains information about the send operation. This object is passed to the requestCallback
delegate when the operation is complete.
Returns
An IAsyncResult object that references the asynchronous send.
Examples
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);
}
}
Remarks
The asynchronous BeginSend operation must be completed by calling the EndSend method. Typically, the method is invoked by the requestCallback
delegate.
This method does not block until the operation completes. To block until the operation is complete, use one of the Send method overloads.
For detailed information about using the asynchronous programming model, see Calling Synchronous Methods Asynchronously.
Applies to
Atsauksmes
https://aka.ms/ContentUserFeedback.
Drīzumā: 2024. gada laikā mēs pakāpeniski pārtrauksim izmantot “GitHub problēmas” kā atsauksmju par saturu mehānismu un aizstāsim to ar jaunu atsauksmju sistēmu. Papildinformāciju skatiet:Iesniegt un skatīt atsauksmes par