Socket.BeginAccept Método

Definição

Inicia uma operação assíncrona para aceitar uma tentativa de conexão de entrada.Begins an asynchronous operation to accept an incoming connection attempt.

Sobrecargas

BeginAccept(Socket, Int32, AsyncCallback, Object)

Inicia uma operação assíncrona para aceitar uma tentativa de conexão de entrada de um soquete especificado e recebe o primeiro bloco de dados enviado pelo aplicativo cliente.Begins an asynchronous operation to accept an incoming connection attempt from a specified socket and receives the first block of data sent by the client application.

BeginAccept(AsyncCallback, Object)

Inicia uma operação assíncrona para aceitar uma tentativa de conexão de entrada.Begins an asynchronous operation to accept an incoming connection attempt.

BeginAccept(Int32, AsyncCallback, Object)

Inicia uma operação assíncrona para aceitar uma tentativa de conexão de entrada e recebe o primeiro bloco de dados enviado pelo aplicativo cliente.Begins an asynchronous operation to accept an incoming connection attempt and receives the first block of data sent by the client application.

BeginAccept(Socket, Int32, AsyncCallback, Object)

Inicia uma operação assíncrona para aceitar uma tentativa de conexão de entrada de um soquete especificado e recebe o primeiro bloco de dados enviado pelo aplicativo cliente.Begins an asynchronous operation to accept an incoming connection attempt from a specified socket and receives the first block of data sent by the client application.

public:
 IAsyncResult ^ BeginAccept(System::Net::Sockets::Socket ^ acceptSocket, int receiveSize, AsyncCallback ^ callback, System::Object ^ state);
public IAsyncResult BeginAccept (System.Net.Sockets.Socket? acceptSocket, int receiveSize, AsyncCallback? callback, object? state);
public IAsyncResult BeginAccept (System.Net.Sockets.Socket acceptSocket, int receiveSize, AsyncCallback callback, object state);
member this.BeginAccept : System.Net.Sockets.Socket * int * AsyncCallback * obj -> IAsyncResult
Public Function BeginAccept (acceptSocket As Socket, receiveSize As Integer, callback As AsyncCallback, state As Object) As IAsyncResult

Parâmetros

acceptSocket
Socket

O objeto Socket aceito.The accepted Socket object. Este valor pode ser null.This value may be null.

receiveSize
Int32

O número máximo de bytes a serem recebidos.The maximum number of bytes to receive.

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 objeto IAsyncResult que faz referência à criação do objeto Socket assíncrono.An IAsyncResult object that references the asynchronous Socket object creation.

Exceções

O objeto Socket foi fechado.The Socket object has been closed.

Windows NT é necessário para esse método.Windows NT is required for this method.

O soquete de aceitação não está escutando conexões.The accepting socket is not listening for connections. É necessário chamar Bind(EndPoint) e Listen(Int32) antes de chamar BeginAccept(AsyncCallback, Object).You must call Bind(EndPoint) and Listen(Int32) before calling BeginAccept(AsyncCallback, Object).

- ou --or- O soquete aceito está associado.The accepted socket is bound.

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

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

Exemplos

O exemplo de código a seguir abre um soquete e aceita uma conexão assíncrona.The following code example opens a socket and accepts an asynchronous connection. Neste exemplo, o Soquete aceita os 10 bytes iniciais de dados e o acceptSocket parâmetro é null , que força o BeginAccept método a criar o soquete aceito.In this example, the socket accepts the initial 10 bytes of data and the acceptSocket parameter is null, which forces the BeginAccept method to create the accepted socket. O número de bytes recebidos e os dados são exibidos no console pelo delegado de retorno de chamada.The number of bytes received and the data are displayed on the console by the callback delegate. Consulte BeginReceive para obter uma descrição de como os dados restantes são recebidos.See BeginReceive for a description of how the remaining data is received.

   // This server waits for a connection and then uses asynchronous operations to
   // accept the connection with initial data sent from the client.
   // Establish the local endpoint for the socket.
   IPHostEntry^ ipHostInfo = Dns::GetHostEntry( Dns::GetHostName() );
   IPAddress^ ipAddress = ipHostInfo->AddressList[ 0 ];
   IPEndPoint^ localEndPoint = gcnew IPEndPoint( ipAddress,11000 );

   // Create a TCP/IP socket.
   Socket^ listener = gcnew Socket( AddressFamily::InterNetwork,SocketType::Stream,ProtocolType::Tcp );

   // Bind the socket to the local endpoint, and listen for incoming connections.
   listener->Bind( localEndPoint );
   listener->Listen( 100 );
   for ( ; ;  )
   {
      // Set the event to nonsignaled state.
      allDone->Reset();

      // Start an asynchronous socket to listen for connections and receive data from the client.
      Console::WriteLine( "Waiting for a connection..." );

      // Accept the connection and receive the first 10 bytes of data. 
      // BeginAccept() creates the accepted socket.
      int receivedDataSize = 10;
      listener->BeginAccept( nullptr, receivedDataSize, gcnew AsyncCallback( AcceptReceiveDataCallback ), listener );

      // Wait until a connection is made and processed before continuing.
      allDone->WaitOne();
   }
}

static void AcceptReceiveDataCallback( IAsyncResult^ ar )
{
   // Get the socket that handles the client request.
   Socket^ listener = dynamic_cast<Socket^>(ar->AsyncState);
   
   // End the operation and display the received data on the console.
   array<Byte>^Buffer;
   int bytesTransferred;
   Socket^ handler = listener->EndAccept( Buffer, bytesTransferred, ar );
   String^ stringTransferred = Encoding::ASCII->GetString( Buffer, 0, bytesTransferred );
   Console::WriteLine( stringTransferred );
   Console::WriteLine( "Size of data transferred is {0}", bytesTransferred );
   
   // Create the state object for the asynchronous receive.
   StateObject^ state = gcnew StateObject;
   state->workSocket = handler;
   handler->BeginReceive( state->buffer, 0, StateObject::BufferSize, static_cast<SocketFlags>(0), gcnew AsyncCallback( ReadCallback ), state );
}

    // This server waits for a connection and then uses asynchronous operations to
    // accept the connection with initial data sent from the client.

    // Establish the local endpoint for the socket.

    IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
    IPAddress ipAddress = ipHostInfo.AddressList[0];
    IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);

    // Create a TCP/IP socket.
    Socket listener = new Socket(AddressFamily.InterNetwork,
        SocketType.Stream, ProtocolType.Tcp );

    // Bind the socket to the local endpoint, and listen for incoming connections.
    listener.Bind(localEndPoint);
    listener.Listen(100);

    while (true)
    {
        // Set the event to nonsignaled state.
        allDone.Reset();

        // Start an asynchronous socket to listen for connections and receive data from the client.
        Console.WriteLine("Waiting for a connection...");

        // Accept the connection and receive the first 10 bytes of data.
        // BeginAccept() creates the accepted socket.
        int receivedDataSize = 10;
        listener.BeginAccept(null, receivedDataSize, new AsyncCallback(AcceptReceiveDataCallback), listener);

        // Wait until a connection is made and processed before continuing.
        allDone.WaitOne();
    }
}

public static void AcceptReceiveDataCallback(IAsyncResult ar)
{
    // Get the socket that handles the client request.
    Socket listener = (Socket) ar.AsyncState;

    // End the operation and display the received data on the console.
    byte[] Buffer;
    int bytesTransferred;
    Socket handler = listener.EndAccept(out Buffer, out bytesTransferred, ar);
    string stringTransferred = Encoding.ASCII.GetString(Buffer, 0, bytesTransferred);

    Console.WriteLine(stringTransferred);
    Console.WriteLine("Size of data transferred is {0}", bytesTransferred);

    // Create the state object for the asynchronous receive.
    StateObject state = new StateObject();
    state.workSocket = handler;
    handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,
    new AsyncCallback(ReadCallback), state);
}

Comentários

Os protocolos orientados a conexão podem usar o BeginAccept método para processar de forma assíncrona as tentativas de conexão de entrada.Connection-oriented protocols can use the BeginAccept method to asynchronously process incoming connection attempts. A aceitação de conexões de forma assíncrona oferece a capacidade de enviar e receber dados em um thread de execução separado.Accepting connections asynchronously gives you the ability to send and receive data within a separate execution thread. Essa sobrecarga permite que você especifique o soquete aceito no acceptSocket parâmetro.This overload allows you to specify the accepted socket in the acceptSocket parameter. Se esse parâmetro for null , o soquete aceito será criado pelo BeginAccept método.If this parameter is null, the accepted socket is created by the BeginAccept method. Você pode especificar o número de bytes a serem aceitos na transferência inicial no receiveSize parâmetro.You can specify the number of bytes to accept in the initial transfer in the receiveSize parameter.

Antes de chamar o BeginAccept método, você deve chamar o Listen método para escutar e enfileirar as solicitações de conexão de entrada.Before calling the BeginAccept method, you must call the Listen method to listen for and queue incoming connection requests.

Você deve criar um método de retorno de chamada que implemente o AsyncCallback delegado e passe seu nome para o BeginAccept método.You must create a callback method that implements the AsyncCallback delegate and pass its name to the BeginAccept method. Para fazer isso, no mínimo, você deve passar o objeto de escuta Socket para BeginAccept por meio do state parâmetro.To do this, at the very minimum, you must pass the listening Socket object to BeginAccept through the state parameter. 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 BeginAccept método por meio do state parâmetro.Pass an instance of this class to the BeginAccept method through the state parameter.

O método de retorno de chamada deve invocar o EndAccept método.Your callback method should invoke the EndAccept method. Quando seu aplicativo chama BeginAccept , o sistema geralmente usa um thread separado para executar o método de retorno de chamada especificado e bloqueia EndAccept até que uma conexão pendente seja recuperada.When your application calls BeginAccept, the system usually uses a separate thread to execute the specified callback method and blocks on EndAccept until a pending connection is retrieved.

EndAccept Retorna um novo Socket objeto que você pode usar para enviar e receber dados com o host remoto.EndAccept returns a new Socket object that you can use to send and receive data with the remote host. Você não pode usar isso retornado Socket para aceitar conexões adicionais da fila de conexão.You cannot use this returned Socket to accept any additional connections from the connection queue. Se você quiser que o thread original seja bloqueado depois de chamar o BeginAccept método, use WaitHandle.WaitOne .If you want the original thread to block after you call the BeginAccept method, use WaitHandle.WaitOne. Chame o método set em um ManualResetEvent no método de retorno de chamada quando desejar que o thread original continue em execução.Call the Set method on a ManualResetEvent in the callback method when you want the original thread to continue executing.

O sistema também pode usar o thread de chamada para invocar o método de retorno de chamada.The system may also use the calling thread to invoke the callback method. Nesse caso, a CompletedSynchronously propriedade em retornado IAsyncResult será definida para indicar que o BeginAccept método foi concluído de forma síncrona.In this case, the CompletedSynchronously property on the returned IAsyncResult will be set to indicate that the BeginAccept method completed synchronously.

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.

Para cancelar uma chamada pendente para o BeginAccept método, feche o Socket .To cancel a pending call to the BeginAccept method, close the Socket. Quando o Close método é chamado enquanto uma operação assíncrona está em andamento, o retorno de chamada fornecido ao BeginAccept método é chamado.When the Close method is called while an asynchronous operation is in progress, the callback provided to the BeginAccept method is called. Uma chamada subsequente para o EndAccept método gerará um ObjectDisposedException para indicar que a operação foi cancelada.A subsequent call to the EndAccept method will throw an ObjectDisposedException to indicate that the operation has been cancelled.

Observação

Você pode usar a RemoteEndPoint Propriedade do objeto retornado Socket para identificar o número da porta e o endereço de rede do host remoto.You can use the RemoteEndPoint property of the returned Socket object to identify the remote host's network address and port number.

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.

Confira também

Aplica-se a

BeginAccept(AsyncCallback, Object)

Inicia uma operação assíncrona para aceitar uma tentativa de conexão de entrada.Begins an asynchronous operation to accept an incoming connection attempt.

public:
 IAsyncResult ^ BeginAccept(AsyncCallback ^ callback, System::Object ^ state);
public IAsyncResult BeginAccept (AsyncCallback? callback, object? state);
public IAsyncResult BeginAccept (AsyncCallback callback, object state);
member this.BeginAccept : AsyncCallback * obj -> IAsyncResult
Public Function BeginAccept (callback As AsyncCallback, state As Object) As IAsyncResult

Parâmetros

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 à criação assíncrona do Socket.An IAsyncResult that references the asynchronous Socket creation.

Exceções

O objeto Socket foi fechado.The Socket object has been closed.

Windows NT é necessário para esse método.Windows NT is required for this method.

O soquete de aceitação não está escutando conexões.The accepting socket is not listening for connections. É necessário chamar Bind(EndPoint) e Listen(Int32) antes de chamar BeginAccept(AsyncCallback, Object).You must call Bind(EndPoint) and Listen(Int32) before calling BeginAccept(AsyncCallback, Object).

- ou --or- O soquete aceito está associado.The accepted socket is bound.

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

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

Exemplos

O exemplo de código a seguir tenta receber uma conexão de entrada de forma assíncrona.The following code example attempts to receive an incoming connection asynchronously.

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
{
   s->Bind( lep );
   s->Listen( 1000 );

   while ( true )
   {
      allDone->Reset();

      Console::WriteLine( "Waiting for a connection..." );
      s->BeginAccept( 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{
        s.Bind(lep);
        s.Listen(1000);

        while(true){
             allDone.Reset();

             Console.WriteLine("Waiting for a connection...");
             s.BeginAccept(new AsyncCallback(Async_Send_Receive.Listen_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
      s.Bind(lep)
      s.Listen(1000)
      
      While True
         allDone.Reset()
         
         Console.WriteLine("Waiting for a connection...")
         s.BeginAccept(New AsyncCallback(AddressOf Async_Send_Receive.Listen_Callback), s)
         
         allDone.WaitOne()
      End While
   Catch e As Exception
      Console.WriteLine(e.ToString())
   End Try
End Sub

Comentários

Os protocolos orientados a conexão podem usar o BeginAccept método para processar de forma assíncrona as tentativas de conexão de entrada.Connection-oriented protocols can use the BeginAccept method to asynchronously process incoming connection attempts. A aceitação de conexões de forma assíncrona oferece a capacidade de enviar e receber dados em um thread de execução separado.Accepting connections asynchronously gives you the ability to send and receive data within a separate execution thread. Antes de chamar o BeginAccept método, você deve chamar o Listen método para escutar e enfileirar as solicitações de conexão de entrada.Before calling the BeginAccept method, you must call the Listen method to listen for and queue incoming connection requests.

Você deve criar um método de retorno de chamada que implemente o AsyncCallback delegado e passe seu nome para o BeginAccept método.You must create a callback method that implements the AsyncCallback delegate and pass its name to the BeginAccept method. Para fazer isso, no mínimo, você deve passar o objeto de escuta Socket para BeginAccept por meio do state parâmetro.To do this, at the very minimum, you must pass the listening Socket object to BeginAccept through the state parameter. 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 BeginAccept método por meio do state parâmetro.Pass an instance of this class to the BeginAccept method through the state parameter.

O método de retorno de chamada deve invocar o EndAccept método.Your callback method should invoke the EndAccept method. Quando seu aplicativo chama BeginAccept , o sistema geralmente usa um thread separado para executar o método de retorno de chamada especificado e bloqueia EndAccept até que uma conexão pendente seja recuperada.When your application calls BeginAccept, the system usually uses a separate thread to execute the specified callback method and blocks on EndAccept until a pending connection is retrieved. EndAccept retornará um novo Socket objeto que você pode usar para enviar e receber dados com o host remoto.EndAccept will return a new Socket object that you can use to send and receive data with the remote host. Você não pode usar isso retornado Socket para aceitar conexões adicionais da fila de conexão.You cannot use this returned Socket to accept any additional connections from the connection queue. Se você quiser que o thread original seja bloqueado depois de chamar o BeginAccept método, use WaitHandle.WaitOne .If you want the original thread to block after you call the BeginAccept method, use WaitHandle.WaitOne. Chame o método set em um ManualResetEvent no método de retorno de chamada quando desejar que o thread original continue em execução.Call the Set method on a ManualResetEvent in the callback method when you want the original thread to continue executing.

O sistema também pode usar o thread de chamada para invocar o método de retorno de chamada.The system may also use the calling thread to invoke the callback method. Nesse caso, a CompletedSynchronously propriedade em retornado IAsyncResult será definida para indicar que o BeginAccept método foi concluído de forma síncrona.In this case, the CompletedSynchronously property on the returned IAsyncResult will be set to indicate that the BeginAccept method completed synchronously.

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.

Para cancelar uma chamada pendente para o BeginAccept método, feche o Socket .To cancel a pending call to the BeginAccept method, close the Socket. Quando o Close método é chamado enquanto uma operação assíncrona está em andamento, o retorno de chamada fornecido ao BeginAccept método é chamado.When the Close method is called while an asynchronous operation is in progress, the callback provided to the BeginAccept method is called. Uma chamada subsequente para o EndAccept método gerará um ObjectDisposedException para indicar que a operação foi cancelada.A subsequent call to the EndAccept method will throw an ObjectDisposedException to indicate that the operation has been cancelled.

Observação

Você pode usar a RemoteEndPoint propriedade de retornada Socket para identificar o número da porta e o endereço de rede do host remoto.You can use the RemoteEndPoint property of the returned Socket to identify the remote host's network address and port number.

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.

Confira também

Aplica-se a

BeginAccept(Int32, AsyncCallback, Object)

Inicia uma operação assíncrona para aceitar uma tentativa de conexão de entrada e recebe o primeiro bloco de dados enviado pelo aplicativo cliente.Begins an asynchronous operation to accept an incoming connection attempt and receives the first block of data sent by the client application.

public:
 IAsyncResult ^ BeginAccept(int receiveSize, AsyncCallback ^ callback, System::Object ^ state);
public IAsyncResult BeginAccept (int receiveSize, AsyncCallback? callback, object? state);
public IAsyncResult BeginAccept (int receiveSize, AsyncCallback callback, object state);
member this.BeginAccept : int * AsyncCallback * obj -> IAsyncResult
Public Function BeginAccept (receiveSize As Integer, callback As AsyncCallback, state As Object) As IAsyncResult

Parâmetros

receiveSize
Int32

O número de bytes a serem aceitos do remetente.The number of bytes to accept from the sender.

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 à criação assíncrona do Socket.An IAsyncResult that references the asynchronous Socket creation.

Exceções

O objeto Socket foi fechado.The Socket object has been closed.

Windows NT é necessário para esse método.Windows NT is required for this method.

O soquete de aceitação não está escutando conexões.The accepting socket is not listening for connections. É necessário chamar Bind(EndPoint) e Listen(Int32) antes de chamar BeginAccept(AsyncCallback, Object).You must call Bind(EndPoint) and Listen(Int32) before calling BeginAccept(AsyncCallback, Object).

- ou --or- O soquete aceito está associado.The accepted socket is bound.

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

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

Exemplos

O exemplo de código a seguir abre um soquete e aceita uma conexão assíncrona.The following code example opens a socket and accepts an asynchronous connection. Neste exemplo, o Soquete aceita os 10 bytes iniciais de dados.In this example, the socket accepts the initial 10 bytes of data. O número de bytes recebidos e os dados são exibidos no console pelo delegado de retorno de chamada.The number of bytes received and the data are displayed on the console by the callback delegate. Consulte BeginReceive para obter uma descrição de como os dados restantes são recebidos.See BeginReceive for a description of how the remaining data is received.

   // This server waits for a connection and then uses asynchronous operations to
   // accept the connection with initial data sent from the client.
   // Establish the local endpoint for the socket.
   IPHostEntry^ ipHostInfo = Dns::GetHostEntry( Dns::GetHostName() );
   IPAddress^ ipAddress = ipHostInfo->AddressList[ 0 ];
   IPEndPoint^ localEndPoint = gcnew IPEndPoint( ipAddress,11000 );
   
   // Create a TCP/IP socket.
   Socket^ listener = gcnew Socket( AddressFamily::InterNetwork,SocketType::Stream,ProtocolType::Tcp );
   
   // Bind the socket to the local endpoint, and listen for incoming connections.
   listener->Bind( localEndPoint );
   listener->Listen( 100 );
   for ( ; ;  )
   {
      
      // Set the event to nonsignaled state.
      allDone->Reset();
      
      // Start an asynchronous socket to listen for connections and receive data from the client.
      Console::WriteLine( "Waiting for a connection..." );
      
      // Accept the connection and receive the first 10 bytes of data.
      int receivedDataSize = 10;
      listener->BeginAccept( receivedDataSize, gcnew AsyncCallback( AcceptReceiveCallback ), listener );
      
      // Wait until a connection is made and processed before continuing.
      allDone->WaitOne();

   }
}

static void AcceptReceiveCallback( IAsyncResult^ ar )
{
   // Get the socket that handles the client request.
   Socket^ listener = dynamic_cast<Socket^>(ar->AsyncState);

   // End the operation and display the received data on the console.
   array<Byte>^Buffer;
   int bytesTransferred;
   Socket^ handler = listener->EndAccept( Buffer, bytesTransferred, ar );
   String^ stringTransferred = Encoding::ASCII->GetString( Buffer, 0, bytesTransferred );
   Console::WriteLine( stringTransferred );
   Console::WriteLine( "Size of data transferred is {0}", bytesTransferred );

   // Create the state object for the asynchronous receive.
   StateObject^ state = gcnew StateObject;
   state->workSocket = handler;
   handler->BeginReceive( state->buffer, 0, StateObject::BufferSize, static_cast<SocketFlags>(0), gcnew AsyncCallback( ReadCallback ), state );
}


    // This server waits for a connection and then uses asynchronous operations to
    // accept the connection with initial data sent from the client.

    // Establish the local endpoint for the socket.

    IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
    IPAddress ipAddress = ipHostInfo.AddressList[0];
    IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);

    // Create a TCP/IP socket.
    Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp );

    // Bind the socket to the local endpoint, and listen for incoming connections.
    listener.Bind(localEndPoint);
    listener.Listen(100);

    while (true)
    {
        // Set the event to nonsignaled state.
        allDone.Reset();

        // Start an asynchronous socket to listen for connections and receive data from the client.
        Console.WriteLine("Waiting for a connection...");

        // Accept the connection and receive the first 10 bytes of data.
        int receivedDataSize = 10;
        listener.BeginAccept(receivedDataSize, new AsyncCallback(AcceptReceiveCallback), listener);

        // Wait until a connection is made and processed before continuing.
        allDone.WaitOne();
    }
}

public static void AcceptReceiveCallback(IAsyncResult ar)
{
    // Get the socket that handles the client request.
    Socket listener = (Socket) ar.AsyncState;

    // End the operation and display the received data on the console.
    byte[] Buffer;
    int bytesTransferred;
    Socket handler = listener.EndAccept(out Buffer, out bytesTransferred, ar);
    string stringTransferred = Encoding.ASCII.GetString(Buffer, 0, bytesTransferred);

    Console.WriteLine(stringTransferred);
    Console.WriteLine("Size of data transferred is {0}", bytesTransferred);

    // Create the state object for the asynchronous receive.
    StateObject state = new StateObject();
    state.workSocket = handler;
    handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,
    new AsyncCallback(ReadCallback), state);
}

Comentários

Os protocolos orientados a conexão podem usar o BeginAccept método para processar de forma assíncrona as tentativas de conexão de entrada.Connection-oriented protocols can use the BeginAccept method to asynchronously process incoming connection attempts. A aceitação de conexões de forma assíncrona permite que você envie e receba dados em um thread de execução separado.Accepting connections asynchronously enables you to send and receive data within a separate execution thread. Essa sobrecarga permite que você especifique o número de bytes a serem aceitos na transferência inicial no receiveSize parâmetro.This overload allows you to specify the number of bytes to accept in the initial transfer in the receiveSize parameter.

Antes de chamar o BeginAccept método, você deve chamar o Listen método para escutar e enfileirar as solicitações de conexão de entrada.Before calling the BeginAccept method, you must call the Listen method to listen for and queue incoming connection requests.

Você deve criar um método de retorno de chamada que implemente o AsyncCallback delegado e passe seu nome para o BeginAccept método.You must create a callback method that implements the AsyncCallback delegate and pass its name to the BeginAccept method. Para fazer isso, no mínimo, você deve passar o objeto de escuta Socket para BeginAccept por meio do state parâmetro.To do this, at the very minimum, you must pass the listening Socket object to BeginAccept through the state parameter. 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 BeginAccept método por meio do state parâmetro.Pass an instance of this class to the BeginAccept method through the state parameter.

O método de retorno de chamada deve invocar o EndAccept método.Your callback method should invoke the EndAccept method. Quando seu aplicativo chama BeginAccept , o sistema geralmente usa um thread separado para executar o método de retorno de chamada especificado e bloqueia EndAccept até que uma conexão pendente seja recuperada.When your application calls BeginAccept, the system usually uses a separate thread to execute the specified callback method and blocks on EndAccept until a pending connection is retrieved.

EndAccept Retorna um novo Socket que você pode usar para enviar e receber dados com o host remoto.EndAccept returns a new Socket that you can use to send and receive data with the remote host. Você não pode usar isso retornado Socket para aceitar conexões adicionais da fila de conexão.You cannot use this returned Socket to accept any additional connections from the connection queue. Se você quiser que o thread original seja bloqueado depois de chamar o BeginAccept método, use WaitHandle.WaitOne .If you want the original thread to block after you call the BeginAccept method, use WaitHandle.WaitOne. Chame o método set em um ManualResetEvent no método de retorno de chamada quando desejar que o thread original continue em execução.Call the Set method on a ManualResetEvent in the callback method when you want the original thread to continue executing.

O sistema também pode usar o thread de chamada para invocar o método de retorno de chamada.The system may also use the calling thread to invoke the callback method. Nesse caso, a CompletedSynchronously propriedade em retornado IAsyncResult será definida para indicar que o BeginAccept método foi concluído de forma síncrona.In this case, the CompletedSynchronously property on the returned IAsyncResult will be set to indicate that the BeginAccept method completed synchronously.

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.

Para cancelar uma chamada pendente para o BeginAccept método, feche o Socket .To cancel a pending call to the BeginAccept method, close the Socket. Quando o Close método é chamado enquanto uma operação assíncrona está em andamento, o retorno de chamada fornecido ao BeginAccept método é chamado.When the Close method is called while an asynchronous operation is in progress, the callback provided to the BeginAccept method is called. Uma chamada subsequente para o EndAccept método gerará um ObjectDisposedException para indicar que a operação foi cancelada.A subsequent call to the EndAccept method will throw an ObjectDisposedException to indicate that the operation has been cancelled.

Observação

Você pode chamar use a RemoteEndPoint Propriedade do objeto retornado Socket para identificar o número da porta e o endereço de rede do host remoto.You can call use the RemoteEndPoint property of the returned Socket object to identify the remote host's network address and port number.

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.

Confira também

Aplica-se a