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

Definição

Começa a receber dados de um dispositivo de rede especificado de maneira assíncrona.Begins to asynchronously receive data from a specified network device.

public:
 IAsyncResult ^ BeginReceiveFrom(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 ^ BeginReceiveFrom(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 BeginReceiveFrom (byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags, ref System.Net.EndPoint remoteEP, AsyncCallback? callback, object? state);
public IAsyncResult BeginReceiveFrom (byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags, ref System.Net.EndPoint remoteEP, AsyncCallback callback, object state);
public IAsyncResult BeginReceiveFrom (byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socket_flags, ref System.Net.EndPoint remote_end, AsyncCallback callback, object state);
member this.BeginReceiveFrom : byte[] * int * int * System.Net.Sockets.SocketFlags * EndPoint * AsyncCallback * obj -> IAsyncResult
member this.BeginReceiveFrom : byte[] * int * int * System.Net.Sockets.SocketFlags * EndPoint * AsyncCallback * obj -> IAsyncResult
Public Function BeginReceiveFrom (buffer As Byte(), offset As Integer, size As Integer, socketFlags As SocketFlags, ByRef remoteEP As EndPoint, callback As AsyncCallback, state As Object) As IAsyncResult
Public Function BeginReceiveFrom (buffer As Byte(), offset As Integer, size As Integer, socket_flags As SocketFlags, ByRef remote_end As EndPoint, callback As AsyncCallback, state As Object) As IAsyncResult

Parâmetros

buffer
Byte[]

Uma matriz do tipo Byte que é o local de armazenamento dos dados recebidos.An array of type Byte that is the storage location for the received data.

offset
Int32

A posição de base zero no parâmetro buffer no qual armazenar os dados.The zero-based position in the buffer parameter at which to store the data.

size
Int32

O número de bytes a serem recebidos.The number of bytes to receive.

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 a fonte de dados.An EndPoint that represents the source of the data.

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 à leitura assíncrona.An IAsyncResult that references the asynchronous read.

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 recebe de forma assíncrona datagramas sem conexão de um host remoto.The following code example asynchronously receives connectionless datagrams from a 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::Dgram,
      ProtocolType::Udp);
   
   IPEndPoint^ sender = gcnew IPEndPoint( IPAddress::Any, 0 );
   EndPoint^ tempRemoteEP = (EndPoint^)( sender );
   s->Connect( sender );
   
   try{
      while(true){
         allDone->Reset();
         StateObject^ so2 = gcnew StateObject();
             so2->workSocket = s;
             Console::WriteLine( "Attempting to Receive data from host.contoso.com" );
         
             s->BeginReceiveFrom( so2->buffer, 0, StateObject::BUFFER_SIZE, SocketFlags::None, tempRemoteEP,
            gcnew AsyncCallback( &Async_Send_Receive::ReceiveFrom_Callback), so2);	
             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.Dgram,
                                     ProtocolType.Udp);

   IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
   EndPoint tempRemoteEP = (EndPoint)sender;
   s.Connect(sender);

   try{
        while(true){
             allDone.Reset();
             StateObject so2 = new StateObject();
             so2.workSocket = s;
             Console.WriteLine("Attempting to Receive data from host.contoso.com");

             s.BeginReceiveFrom(so2.buffer, 0, StateObject.BUFFER_SIZE,0, ref tempRemoteEP,
                                   new AsyncCallback(Async_Send_Receive.ReceiveFrom_Callback), so2);	
             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.DGram, ProtocolType.Udp)
   
   Dim sender As New IPEndPoint(IPAddress.Any, 0)
   Dim tempRemoteEP As EndPoint = CType(sender, EndPoint)
   s.Connect(sender)
   Try
      While True
         allDone.Reset()
         Dim so2 As New StateObject()
         so2.workSocket = s
         Console.WriteLine("Attempting to Receive data from host.contoso.com")
         
         s.BeginReceiveFrom(so2.buffer, 0, StateObject.BUFFER_SIZE, 0, tempRemoteEP, New AsyncCallback(AddressOf Async_Send_Receive.ReceiveFrom_Callback), so2)
         allDone.WaitOne()
      End While
   Catch e As Exception
      Console.WriteLine(e.ToString())
   End Try
End Sub

Comentários

O BeginReceiveFrom método inicia a leitura assíncrona de datagramas sem conexão de um host remoto.The BeginReceiveFrom method starts asynchronously reading connectionless datagrams from a remote host. Chamar o BeginReceiveFrom método lhe dá a capacidade de receber dados em um thread de execução separado.Calling the BeginReceiveFrom method gives you the ability to receive data within a separate execution thread.

Você pode criar um método de retorno de chamada que implemente o AsyncCallback delegado e passe seu nome para o BeginReceiveFrom método.You can create a callback method that implements the AsyncCallback delegate and pass its name to the BeginReceiveFrom 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 BeginReceiveFrom método por meio do state parâmetro.Pass an instance of this class to the BeginReceiveFrom method through the state parameter.

O método de retorno de chamada deve invocar o EndReceiveFrom método.Your callback method should invoke the EndReceiveFrom method. Quando seu aplicativo chama BeginReceiveFrom , o sistema usará um thread separado para executar o método de retorno de chamada especificado e ele será bloqueado EndReceiveFrom até que o Socket Leia dados ou gere uma exceção.When your application calls BeginReceiveFrom, the system will use a separate thread to execute the specified callback method, and it will block on EndReceiveFrom until the Socket reads data or throws an exception. Se você quiser que o thread original seja bloqueado depois de chamar o BeginReceiveFrom método, use WaitHandle.WaitOne .If you want the original thread to block after you call the BeginReceiveFrom method, use WaitHandle.WaitOne. 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 on writing callback methods, see Marshaling a Delegate as a Callback Method.

Observação

Antes de chamar BeginReceiveFrom , você deve associar explicitamente o Socket a um ponto de extremidade local usando o Bind método ou BeginReceiveFrom gerará um SocketException .Before calling BeginReceiveFrom, you must explicitly bind the Socket to a local endpoint using the Bind method, or BeginReceiveFrom will throw a SocketException.

Esse método lê dados no buffer parâmetro e captura o ponto de extremidade do host remoto do qual os dados são enviados.This method reads data into the buffer parameter, and captures the remote host endpoint from which the data is sent. Para obter informações sobre como recuperar esse ponto de extremidade, consulte EndReceiveFrom .For information on how to retrieve this endpoint, refer to EndReceiveFrom. Esse método é mais útil se você pretende receber de forma assíncrona datagramas sem conexão de um host desconhecido ou vários hosts.This method is most useful if you intend to asynchronously receive connectionless datagrams from an unknown host or multiple hosts. Nesses casos, BeginReceiveFrom o lerá o primeiro datagrama enfileirado recebido no buffer de rede local.In these cases, BeginReceiveFrom will read the first enqueued datagram received into the local network buffer. Se o datagrama recebido for maior que o tamanho buffer , o BeginReceiveFrom método preencherá o buffer máximo possível da mensagem, e lançará um SocketException .If the datagram you receive is larger than the size of buffer, the BeginReceiveFrom method will fill buffer with as much of the message as is possible, and throw a SocketException. Se você estiver usando um protocolo não confiável, os dados em excesso serão perdidos.If you are using an unreliable protocol, the excess data will be lost. Se você estiver usando um protocolo confiável, os dados em excesso serão mantidos pelo provedor de serviços e você poderá recuperá-los chamando o BeginReceiveFrom método com um buffer grande o suficiente.If you are using a reliable protocol, the excess data will be retained by the service provider and you can retrieve it by calling the BeginReceiveFrom method with a large enough buffer.

Para garantir que o ponto de extremidade de host remoto sempre seja retornado, um aplicativo deve associar explicitamente o Socket a um ponto de extremidade local usando o Bind método e, em seguida, chamar o SetSocketOption método com o optionLevel parâmetro definido como IP ou IPv6 conforme apropriado, o optionName parâmetro definido como e PacketInformation o optionValue parâmetro para habilitar essa opção antes de chamar o BeginReceiveFrom método.To guarantee that the remote host endpoint is always returned, an application should explicitly bind the Socket to a local endpoint using the Bind method and then call the SetSocketOption method with the optionLevel parameter set to IP or IPv6 as appropriate, the optionName parameter set to PacketInformation, and the optionValue parameter to enable this option before calling the BeginReceiveFrom method. Caso contrário, é possível que o ponto de extremidade do host remoto não seja retornado quando o remetente enviou um número de datagramas antes que o destinatário tenha chamado o BeginReceiveFrom método.Otherwise, it is possible for the remote host endpoint to not be returned when the sender has sent a number of datagrams before the receiver has called the BeginReceiveFrom method.

Embora BeginReceiveFrom o seja destinado a protocolos sem conexão, você também pode usar um protocolo orientado por conexão.Although BeginReceiveFrom is intended for connectionless protocols, you can use a connection-oriented protocol as well. Se você optar por fazer isso, deverá primeiro estabelecer uma conexão de host remoto chamando o Connect / BeginConnect método ou aceitar uma solicitação de conexão de entrada chamando o Accept método ou BeginAccept .If you choose to do so, you must first either establish a remote host connection by calling the Connect / BeginConnect method or accept an incoming connection request by calling the Accept or BeginAccept method. Se você chamar o BeginReceiveFrom método antes de estabelecer ou aceitar uma conexão, receberá um SocketException .If you call the BeginReceiveFrom method before establishing or accepting a connection, you will get a SocketException. Você também pode estabelecer um host remoto padrão para um protocolo sem conexão antes de chamar o BeginReceiveFrom método.You can also establish a default remote host for a connectionless protocol prior to calling the BeginReceiveFrom method. Em qualquer um desses casos, o BeginReceiveFrom método irá ignorar o remoteEP parâmetro e receber apenas dados do host remoto conectado ou padrão.In either of these cases, the BeginReceiveFrom method will ignore the remoteEP parameter and only receive data from the connected or default remote host.

Com soquetes orientados a conexão, BeginReceiveFrom o lerá a quantidade de dados que está disponível até o número de bytes especificado pelo size parâmetro.With connection-oriented sockets, BeginReceiveFrom will read as much data as is available up to the number of bytes specified by the size parameter.

Para cancelar um pendente BeginReceiveFrom , chame o Close método.To cancel a pending BeginReceiveFrom, call the Close method.

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