Socket.BeginSendTo(Byte[], Int32, Int32, SocketFlags, EndPoint, AsyncCallback, Object) Método

Definição

Envia dados de maneira assíncrona para um host remoto específico.Sends data asynchronously to a specific remote host.

public:
 IAsyncResult ^ BeginSendTo(cli::array <System::Byte> ^ buffer, int offset, int size, System::Net::Sockets::SocketFlags socketFlags, System::Net::EndPoint ^ remoteEP, AsyncCallback ^ callback, System::Object ^ state);
public:
 IAsyncResult ^ BeginSendTo(cli::array <System::Byte> ^ buffer, int offset, int size, System::Net::Sockets::SocketFlags socket_flags, System::Net::EndPoint ^ remote_end, AsyncCallback ^ callback, System::Object ^ state);
public IAsyncResult BeginSendTo (byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags, System.Net.EndPoint remoteEP, AsyncCallback? callback, object? state);
public IAsyncResult BeginSendTo (byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags, System.Net.EndPoint remoteEP, AsyncCallback callback, object state);
public IAsyncResult BeginSendTo (byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socket_flags, System.Net.EndPoint remote_end, AsyncCallback callback, object state);
member this.BeginSendTo : byte[] * int * int * System.Net.Sockets.SocketFlags * System.Net.EndPoint * AsyncCallback * obj -> IAsyncResult
member this.BeginSendTo : byte[] * int * int * System.Net.Sockets.SocketFlags * System.Net.EndPoint * AsyncCallback * obj -> IAsyncResult
Public Function BeginSendTo (buffer As Byte(), offset As Integer, size As Integer, socketFlags As SocketFlags, remoteEP As EndPoint, callback As AsyncCallback, state As Object) As IAsyncResult
Public Function BeginSendTo (buffer As Byte(), offset As Integer, size As Integer, socket_flags As SocketFlags, remote_end As EndPoint, callback As AsyncCallback, state As Object) As IAsyncResult

Parâmetros

buffer
Byte[]

Uma matriz do tipo Byte que contém os dados a serem enviados.An array of type Byte that contains the data to send.

offset
Int32

A posição de base zero no buffer na qual começar a enviar dados.The zero-based position in buffer at which to begin sending data.

size
Int32

O número de bytes a serem enviados.The number of bytes to send.

socketFlagssocket_flags
SocketFlags

Uma combinação bit a bit dos valores SocketFlags.A bitwise combination of the SocketFlags values.

remoteEPremote_end
EndPoint

Um EndPoint que representa o dispositivo remoto.An EndPoint that represents the remote device.

callback
AsyncCallback

O delegado AsyncCallback.The AsyncCallback delegate.

state
Object

Um objeto que contém informações de estado para essa solicitação.An object that contains state information for this request.

Retornos

IAsyncResult

Um IAsyncResult que faz referência ao envio assíncrono.An IAsyncResult that references the asynchronous send.

Exceções

buffer é null.buffer is null.

- ou --or- remoteEP é null.remoteEP is null.

Ocorreu um erro ao tentar acessar o soquete.An error occurred when attempting to access the socket.

offset é menor que 0.offset is less than 0.

- ou --or- offset é maior que o comprimento do buffer.offset is greater than the length of buffer.

- ou --or- size é menor que 0.size is less than 0.

- ou --or- size é maior que o comprimento da subtração de buffer e do valor do parâmetro offset.size is greater than the length of buffer minus the value of the offset parameter.

O Socket foi fechado.The Socket has been closed.

Um chamador mais alto na pilha de chamadas não tem permissão para a operação solicitada.A caller higher in the call stack does not have permission for the requested operation.

Exemplos

O exemplo de código a seguir envia dados de forma assíncrona para o host remoto especificado.The following code example asynchronously sends data to the specified remote host.

IPHostEntry^ lipa = Dns::Resolve( "host.contoso.com" );
IPEndPoint^ lep = gcnew IPEndPoint( lipa->AddressList[ 0 ], 11000 );

Socket^ s = gcnew Socket( lep->Address->AddressFamily,
   SocketType::Stream,
   ProtocolType::Tcp );
try
{
   while ( true )
   {
      allDone->Reset();

      array<Byte>^ buff = Encoding::ASCII->GetBytes( "This is a test" );

      Console::WriteLine( "Sending Message Now.." );
      s->BeginSendTo( buff, 0, buff->Length, SocketFlags::None, lep,
         gcnew AsyncCallback( &Async_Send_Receive::Connect_Callback ), s );

      allDone->WaitOne();
   }
}
catch ( Exception^ e ) 
{
   Console::WriteLine( e );
}
IPHostEntry lipa = Dns.Resolve("host.contoso.com");
IPEndPoint lep = new IPEndPoint(lipa.AddressList[0], 11000);

   Socket s = new Socket(lep.Address.AddressFamily,
                               SocketType.Stream,
                                     ProtocolType.Tcp);
   try{

             while(true){
             allDone.Reset();

             byte[] buff = Encoding.ASCII.GetBytes("This is a test");

             Console.WriteLine("Sending Message Now..");
             s.BeginSendTo(buff, 0, buff.Length, 0, lep, new AsyncCallback(Async_Send_Receive.SendTo_Callback), s);

             allDone.WaitOne();
        }
   }
   catch (Exception e){
        Console.WriteLine(e.ToString());
   }
   Dim lipa As IPHostEntry = Dns.Resolve("host.contoso.com")
   Dim lep As New IPEndPoint(lipa.AddressList(0), 11000)
   
   Dim s As New Socket(lep.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp)
   Try
      
      While True
         allDone.Reset()
         
         Dim buff As Byte() = Encoding.ASCII.GetBytes("This is a test")
         
         Console.WriteLine("Sending Message Now..")
         s.BeginSendTo(buff, 0, buff.Length, 0, lep, New AsyncCallback(AddressOf Async_Send_Receive.SendTo_Callback), s)
         
         allDone.WaitOne()
      End While
   Catch e As Exception
      Console.WriteLine(e.ToString())
   End Try
End Sub

Comentários

O BeginSendTo método inicia uma operação de envio assíncrona para o host remoto especificado no remoteEP parâmetro.The BeginSendTo method starts an asynchronous send operation to the remote host specified in the remoteEP parameter. Chamar o BeginSendTo método lhe dá a capacidade de enviar dados dentro de um thread de execução separado.Calling the BeginSendTo method gives you the ability to send data within a separate execution thread. Embora seja destinado a protocolos sem conexão, BeginSendTo o funciona com protocolos orientados a conexões e conexão.Although intended for connectionless protocols, BeginSendTo works with both connectionless and connection-oriented protocols.

Você pode criar um método de retorno de chamada que implemente o AsyncCallback delegado e passe seu nome para o BeginSendTo método.You can create a callback method that implements the AsyncCallback delegate and pass its name to the BeginSendTo method. Para fazer isso, no mínimo, o state parâmetro deve conter a conexão ou o padrão Socket que está sendo usado para comunicação.To do this, at the very minimum, your state parameter must contain the connected or default Socket being used for communication. Se o retorno de chamada precisar de mais informações, você poderá criar uma pequena classe para manter o Socket e as outras informações necessárias.If your callback needs more information, you can create a small class to hold the Socket, and the other required information. Passe uma instância dessa classe para o BeginSendTo método por meio do state parâmetro.Pass an instance of this class to the BeginSendTo method through the state parameter.

O método de retorno de chamada deve invocar o EndSendTo método.Your callback method should invoke the EndSendTo method. Quando seu aplicativo chama BeginSendTo , o sistema usará um thread separado para executar o método de retorno de chamada especificado e será bloqueado EndSendTo até que o Socket envie o número de bytes solicitados ou gera uma exceção.When your application calls BeginSendTo, the system will use a separate thread to execute the specified callback method, and will block on EndSendTo until the Socket sends the number of bytes requested or throws an exception. Se você quiser que o thread original seja bloqueado depois de chamar o BeginSendTo método, use o WaitHandle.WaitOne método.If you want the original thread to block after you call the BeginSendTo method, use the WaitHandle.WaitOne method. Chame o método set em um T:System.Threading.ManualResetEvent no método de retorno de chamada quando desejar que o thread original continue em execução.Call the Set method on a T:System.Threading.ManualResetEvent in the callback method when you want the original thread to continue executing. Para obter informações adicionais sobre como escrever métodos de retorno de chamada , consulte Empacotando um delegado como um método de retorno de chamada.For additional information about writing callback methods see Marshaling a Delegate as a Callback Method.

Se você estiver usando um protocolo orientado a conexão, primeiro deverá chamar o Connect método,, BeginConnect Accept ou BeginAccept , ou BeginSendTo gerará um SocketException .If you are using a connection-oriented protocol, you must first call the Connect, BeginConnect, Accept, or BeginAccept method, or BeginSendTo will throw a SocketException. BeginSendTo irá ignorar o remoteEP parâmetro e enviar dados para o EndPoint estabelecido no Connect método, BeginConnect , Accept ou BeginAccept .BeginSendTo will ignore the remoteEP parameter and send data to the EndPoint established in the Connect, BeginConnect, Accept, or BeginAccept method.

Se você estiver usando um protocolo sem conexão, não será necessário estabelecer um host remoto padrão com o Connect BeginConnect método ou antes de chamar SendTo .If you are using a connectionless protocol, you do not need to establish a default remote host with the Connect or BeginConnect method prior to calling SendTo. Você só precisa fazer isso se pretender chamar o BeginSend método.You only need to do this if you intend to call the BeginSend method. Se você chamar o Connect método ou BeginConnect antes de chamar SendTo , o remoteEP parâmetro substituirá o host remoto padrão especificado para essa operação de envio.If you do call the Connect or BeginConnect method prior to calling SendTo, the remoteEP parameter will override the specified default remote host for that send operation only. Você também não é obrigado a chamar o Bind método.You are also not required to call the Bind method. Nesse caso, o provedor de serviços subjacente atribuirá o número de porta e o endereço de rede local mais apropriado.In this case, the underlying service provider will assign the most appropriate local network address and port number. Use um número de porta zero se desejar que o provedor de serviços subjacente selecione uma porta livre.Use a port number of zero if you want the underlying service provider to select a free port. Se você precisar identificar o endereço de rede local atribuído e o número da porta, poderá usar a LocalEndPoint Propriedade depois que o EndSendTo método for concluído com êxito.If you need to identify the assigned local network address and port number, you can use the LocalEndPoint property after the EndSendTo method successfully completes.

Se você quiser enviar dados para um endereço de difusão, primeiro você deve chamar o SetSocketOption método e definir a opção de soquete como SocketOptionName.Broadcast .If you want to send data to a broadcast address, you must first call the SetSocketOption method and set the socket option to SocketOptionName.Broadcast. -Você também deve ter certeza de que o tamanho do buffer não exceda o tamanho máximo do pacote do provedor de serviços subjacente.-You must also be sure that the size of your buffer does not exceed the maximum packet size of the underlying service provider. Se tiver, o datagrama não será enviado e EndSendTo gerará um SocketException .If it does, the datagram will not be sent and EndSendTo will throw a SocketException.

Se você especificar o DontRoute sinalizador como o socketflags parâmetro, os dados que você está enviando não serão roteados.If you specify the DontRoute flag as the socketflags parameter, the data you are sending will not be routed.

Observação

Se você receber um SocketException , use a SocketException.ErrorCode propriedade para obter o código de erro específico.If you receive a SocketException, use the SocketException.ErrorCode property to obtain the specific error code. Depois de obter esse código, consulte a documentação do código de erro da API do Windows Sockets versão 2 para obter uma descrição detalhada do erro.After you have obtained this code, refer to the Windows Sockets version 2 API error code documentation for a detailed description of the error.

Observação

Esse membro emite o rastreamento de informações quando você ativa o rastreamento de rede em seu aplicativo.This member outputs trace information when you enable network tracing in your application. Para obter mais informações, consulte rastreamento de rede na .NET Framework.For more information, see Network Tracing in the .NET Framework.

Observação

O contexto de execução (o contexto de segurança, o usuário representado e o contexto de chamada) é armazenado em cache para os métodos assíncronos Socket .The execution context (the security context, the impersonated user, and the calling context) is cached for the asynchronous Socket methods. Após o primeiro uso de um contexto específico (um método assíncrono específico Socket , uma Socket instância específica e um retorno de chamada específico), os usos subsequentes desse contexto verão uma melhoria no desempenho.After the first use of a particular context (a specific asynchronous Socket method, a specific Socket instance, and a specific callback), subsequent uses of that context will see a performance improvement.

Aplica-se a

Confira também