Socket.BeginAccept Socket.BeginAccept Socket.BeginAccept Socket.BeginAccept Method

Definición

Comienza una operación asincrónica para aceptar un intento de conexión entrante.Begins an asynchronous operation to accept an incoming connection attempt.

Sobrecargas

BeginAccept(AsyncCallback, Object) BeginAccept(AsyncCallback, Object) BeginAccept(AsyncCallback, Object) BeginAccept(AsyncCallback, Object)

Comienza una operación asincrónica para aceptar un intento de conexión entrante.Begins an asynchronous operation to accept an incoming connection attempt.

BeginAccept(Int32, AsyncCallback, Object) BeginAccept(Int32, AsyncCallback, Object) BeginAccept(Int32, AsyncCallback, Object) BeginAccept(Int32, AsyncCallback, Object)

Comienza una operación asincrónica para aceptar un intento de conexión entrante y recibe el primer bloque de datos enviado por la aplicación 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) BeginAccept(Socket, Int32, AsyncCallback, Object) BeginAccept(Socket, Int32, AsyncCallback, Object) BeginAccept(Socket, Int32, AsyncCallback, Object)

Comienza una operación asincrónica para aceptar un intento de conexión entrante desde un socket específico y recibe el primer bloque de datos enviado por la aplicación 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) BeginAccept(AsyncCallback, Object) BeginAccept(AsyncCallback, Object) BeginAccept(AsyncCallback, Object)

Comienza una operación asincrónica para aceptar un intento de conexión entrante.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);
member this.BeginAccept : AsyncCallback * obj -> IAsyncResult
Public Function BeginAccept (callback As AsyncCallback, state As Object) As IAsyncResult

Parámetros

state
Object Object Object Object

Objeto que contiene la información de estado para esta solicitud.An object that contains state information for this request.

Devoluciones

IAsyncResult que hace referencia a la creación asincrónica de Socket.An IAsyncResult that references the asynchronous Socket creation.

Excepciones

Se requiere Windows NT para este método.Windows NT is required for this method.

El socket receptor no realiza escuchas de conexiones.The accepting socket is not listening for connections. Debe llamar a Bind(EndPoint) y a Listen(Int32) antes de llamar a BeginAccept(AsyncCallback, Object).You must call Bind(EndPoint) and Listen(Int32) before calling BeginAccept(AsyncCallback, Object).

o bien-or- El socket aceptado se encuentra enlazado.The accepted socket is bound.

Error al intentar acceder al socket.An error occurred when attempting to access the socket.

Ejemplos

En el ejemplo de código siguiente se intenta recibir una conexión entrante de forma asincrónica.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 'Listen

Comentarios

Los protocolos orientados a la conexión BeginAccept pueden utilizar el método para procesar asincrónicamente los intentos de conexión entrantes.Connection-oriented protocols can use the BeginAccept method to asynchronously process incoming connection attempts. Aceptar conexiones de forma asincrónica le permite enviar y recibir datos en un subproceso de ejecución independiente.Accepting connections asynchronously gives you the ability to send and receive data within a separate execution thread. Antes de llamar BeginAccept al método, debe Listen llamar al método para escuchar y poner en cola las solicitudes de conexión entrantes.Before calling the BeginAccept method, you must call the Listen method to listen for and queue incoming connection requests.

Debe crear un método de devolución de llamada que implemente el AsyncCallback delegado y pasar su nombre BeginAccept al método.You must create a callback method that implements the AsyncCallback delegate and pass its name to the BeginAccept method. Para ello, como mínimo, debe pasar el objeto de escucha Socket a BeginAccept a través del state parámetro.To do this, at the very minimum, you must pass the listening Socket object to BeginAccept through the state parameter. Si la devolución de llamada necesita más información, puede crear una clase pequeña para contener Socket y la otra información necesaria.If your callback needs more information, you can create a small class to hold the Socket and the other required information. Pase una instancia de esta clase al BeginAccept método a través del state parámetro.Pass an instance of this class to the BeginAccept method through the state parameter.

El método de devolución de llamada EndAccept debe invocar el método.Your callback method should invoke the EndAccept method. Cuando la aplicación llama BeginAccepta, el sistema normalmente usa un subproceso independiente para ejecutar el método de devolución de EndAccept llamada especificado y se bloquea hasta que se recupera una conexión pendiente.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. EndAcceptdevolverá un Socket nuevo objeto que puede usar para enviar y recibir datos con el host remoto.EndAccept will return a new Socket object that you can use to send and receive data with the remote host. No puede usar este devuelto Socket para aceptar conexiones adicionales de la cola de conexión.You cannot use this returned Socket to accept any additional connections from the connection queue. Si desea que el subproceso original se bloquee después de BeginAccept llamar al método WaitHandle.WaitOne, use.If you want the original thread to block after you call the BeginAccept method, use WaitHandle.WaitOne. Llame al método Set en un ManualResetEvent en el método de devolución de llamada cuando desee que el subproceso original continúe ejecutándose.Call the Set method on a ManualResetEvent in the callback method when you want the original thread to continue executing.

El sistema también puede usar el subproceso que realiza la llamada para invocar el método de devolución de llamada.The system may also use the calling thread to invoke the callback method. En este caso, la CompletedSynchronously propiedad del devuelto IAsyncResult se establecerá para indicar que el BeginAccept método se completó sincrónicamente.In this case, the CompletedSynchronously property on the returned IAsyncResult will be set to indicate that the BeginAccept method completed synchronously.

Para obtener información adicional sobre cómo escribir métodos de devolución de llamada , vea Serialización de un delegado como método de devolución de llamada.For additional information on writing callback methods see Marshaling a Delegate as a Callback Method.

Para cancelar una llamada pendiente al BeginAccept método, cierre el. SocketTo cancel a pending call to the BeginAccept method, close the Socket. Cuando se llama al BeginAccept métodomientrasunaoperaciónasincrónicaestáencurso,sellamaaladevolucióndellamadaproporcionadaalmétodo.CloseWhen the Close method is called while an asynchronous operation is in progress, the callback provided to the BeginAccept method is called. Una llamada subsiguiente al EndAccept método producirá una excepción ObjectDisposedException para indicar que la operación se ha cancelado.A subsequent call to the EndAccept method will throw an ObjectDisposedException to indicate that the operation has been cancelled.

Nota

Puede utilizar la RemoteEndPoint propiedad del devuelto Socket para identificar la dirección de red y el número de puerto del host remoto.You can use the RemoteEndPoint property of the returned Socket to identify the remote host's network address and port number.

Nota

Si recibe un SocketException, utilice la SocketException.ErrorCode propiedad para obtener el código de error específico.If you receive a SocketException, use the SocketException.ErrorCode property to obtain the specific error code. Después de obtener este código, consulte la documentación del código de error de la API de Windows Sockets versión 2 para obtener una descripción detallada del error.After you have obtained this code, refer to the Windows Sockets version 2 API error code documentation for a detailed description of the error.

Nota

Este miembro genera información de seguimiento cuando se habilita el seguimiento de red en la aplicación.This member outputs trace information when you enable network tracing in your application. Para obtener más información, consulte seguimiento de red en el .NET Framework.For more information, see Network Tracing in the .NET Framework.

Nota

El contexto de ejecución (el contexto de seguridad, el usuario suplantado y el contexto de llamada) se almacena en caché Socket para los métodos asincrónicos.The execution context (the security context, the impersonated user, and the calling context) is cached for the asynchronous Socket methods. Después del primer uso de un contexto determinado (un Socket método asincrónico concreto, una instancia específica Socket y una devolución de llamada específica), los usos posteriores de ese contexto verán una mejora del rendimiento.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.

Consulte también:

BeginAccept(Int32, AsyncCallback, Object) BeginAccept(Int32, AsyncCallback, Object) BeginAccept(Int32, AsyncCallback, Object) BeginAccept(Int32, AsyncCallback, Object)

Comienza una operación asincrónica para aceptar un intento de conexión entrante y recibe el primer bloque de datos enviado por la aplicación 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);
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 Int32 Int32 Int32

Número de bytes que se han de aceptar del remitente.The number of bytes to accept from the sender.

state
Object Object Object Object

Objeto que contiene la información de estado para esta solicitud.An object that contains state information for this request.

Devoluciones

IAsyncResult que hace referencia a la creación asincrónica de Socket.An IAsyncResult that references the asynchronous Socket creation.

Excepciones

Se requiere Windows NT para este método.Windows NT is required for this method.

El socket receptor no realiza escuchas de conexiones.The accepting socket is not listening for connections. Debe llamar a Bind(EndPoint) y a Listen(Int32) antes de llamar a BeginAccept(AsyncCallback, Object).You must call Bind(EndPoint) and Listen(Int32) before calling BeginAccept(AsyncCallback, Object).

O bien-or- El socket aceptado se encuentra enlazado.The accepted socket is bound.

Error al intentar acceder al socket.An error occurred when attempting to access the socket.

Ejemplos

En el ejemplo de código siguiente se abre un socket y se acepta una conexión asincrónica.The following code example opens a socket and accepts an asynchronous connection. En este ejemplo, el socket acepta los 10 bytes de datos iniciales.In this example, the socket accepts the initial 10 bytes of data. El delegado de devolución de llamada muestra el número de bytes recibidos y los datos en la consola.The number of bytes received and the data are displayed on the console by the callback delegate. Vea BeginReceive para obtener una descripción de cómo se reciben los datos restantes.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);
}

Comentarios

Los protocolos orientados a la conexión BeginAccept pueden utilizar el método para procesar asincrónicamente los intentos de conexión entrantes.Connection-oriented protocols can use the BeginAccept method to asynchronously process incoming connection attempts. Aceptar conexiones de forma asincrónica permite enviar y recibir datos en un subproceso de ejecución independiente.Accepting connections asynchronously enables you to send and receive data within a separate execution thread. Esta sobrecarga permite especificar el número de bytes que se van a aceptar en la transferencia inicial en receiveSize el parámetro.This overload allows you to specify the number of bytes to accept in the initial transfer in the receiveSize parameter.

Antes de llamar BeginAccept al método, debe Listen llamar al método para escuchar y poner en cola las solicitudes de conexión entrantes.Before calling the BeginAccept method, you must call the Listen method to listen for and queue incoming connection requests.

Debe crear un método de devolución de llamada que implemente el AsyncCallback delegado y pasar su nombre BeginAccept al método.You must create a callback method that implements the AsyncCallback delegate and pass its name to the BeginAccept method. Para ello, como mínimo, debe pasar el objeto de escucha Socket a BeginAccept a través del state parámetro.To do this, at the very minimum, you must pass the listening Socket object to BeginAccept through the state parameter. Si la devolución de llamada necesita más información, puede crear una clase pequeña para contener Socket y la otra información necesaria.If your callback needs more information, you can create a small class to hold the Socket and the other required information. Pase una instancia de esta clase al BeginAccept método a través del state parámetro.Pass an instance of this class to the BeginAccept method through the state parameter.

El método de devolución de llamada EndAccept debe invocar el método.Your callback method should invoke the EndAccept method. Cuando la aplicación llama BeginAccepta, el sistema normalmente usa un subproceso independiente para ejecutar el método de devolución de EndAccept llamada especificado y se bloquea hasta que se recupera una conexión pendiente.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.

EndAcceptDevuelve un nuevo Socket que puede usar para enviar y recibir datos con el host remoto.EndAccept returns a new Socket that you can use to send and receive data with the remote host. No puede usar este devuelto Socket para aceptar conexiones adicionales de la cola de conexión.You cannot use this returned Socket to accept any additional connections from the connection queue. Si desea que el subproceso original se bloquee después de BeginAccept llamar al método WaitHandle.WaitOne, use.If you want the original thread to block after you call the BeginAccept method, use WaitHandle.WaitOne. Llame al método Set en un ManualResetEvent en el método de devolución de llamada cuando desee que el subproceso original continúe ejecutándose.Call the Set method on a ManualResetEvent in the callback method when you want the original thread to continue executing.

El sistema también puede usar el subproceso que realiza la llamada para invocar el método de devolución de llamada.The system may also use the calling thread to invoke the callback method. En este caso, la CompletedSynchronously propiedad del devuelto IAsyncResult se establecerá para indicar que el BeginAccept método se completó sincrónicamente.In this case, the CompletedSynchronously property on the returned IAsyncResult will be set to indicate that the BeginAccept method completed synchronously.

Para obtener información adicional sobre cómo escribir métodos de devolución de llamada , vea Serialización de un delegado como método de devolución de llamada.For additional information on writing callback methods see Marshaling a Delegate as a Callback Method.

Para cancelar una llamada pendiente al BeginAccept método, cierre el. SocketTo cancel a pending call to the BeginAccept method, close the Socket. Cuando se llama al BeginAccept métodomientrasunaoperaciónasincrónicaestáencurso,sellamaaladevolucióndellamadaproporcionadaalmétodo.CloseWhen the Close method is called while an asynchronous operation is in progress, the callback provided to the BeginAccept method is called. Una llamada subsiguiente al EndAccept método producirá una excepción ObjectDisposedException para indicar que la operación se ha cancelado.A subsequent call to the EndAccept method will throw an ObjectDisposedException to indicate that the operation has been cancelled.

Nota

Puede llamar a use la RemoteEndPoint propiedad del objeto devuelto Socket para identificar la dirección de red y el número de puerto del 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.

Nota

Si recibe un SocketException, utilice la SocketException.ErrorCode propiedad para obtener el código de error específico.If you receive a SocketException, use the SocketException.ErrorCode property to obtain the specific error code. Después de obtener este código, consulte la documentación del código de error de la API de Windows Sockets versión 2 para obtener una descripción detallada del error.After you have obtained this code, refer to the Windows Sockets version 2 API error code documentation for a detailed description of the error.

Nota

Este miembro genera información de seguimiento cuando se habilita el seguimiento de red en la aplicación.This member outputs trace information when you enable network tracing in your application. Para obtener más información, consulte seguimiento de red en el .NET Framework.For more information, see Network Tracing in the .NET Framework.

Nota

El contexto de ejecución (el contexto de seguridad, el usuario suplantado y el contexto de llamada) se almacena en caché Socket para los métodos asincrónicos.The execution context (the security context, the impersonated user, and the calling context) is cached for the asynchronous Socket methods. Después del primer uso de un contexto determinado (un Socket método asincrónico concreto, una instancia específica Socket y una devolución de llamada específica), los usos posteriores de ese contexto verán una mejora del rendimiento.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.

Consulte también:

BeginAccept(Socket, Int32, AsyncCallback, Object) BeginAccept(Socket, Int32, AsyncCallback, Object) BeginAccept(Socket, Int32, AsyncCallback, Object) BeginAccept(Socket, Int32, AsyncCallback, Object)

Comienza una operación asincrónica para aceptar un intento de conexión entrante desde un socket específico y recibe el primer bloque de datos enviado por la aplicación 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);
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 Socket Socket Socket

Objeto Socket aceptado.The accepted Socket object. Este valor puede ser null.This value may be null.

receiveSize
Int32 Int32 Int32 Int32

Número máximo de bytes que se va a recibir.The maximum number of bytes to receive.

state
Object Object Object Object

Objeto que contiene la información de estado para esta solicitud.An object that contains state information for this request.

Devoluciones

Objeto IAsyncResult que hace referencia a la creación asincrónica del objeto Socket.An IAsyncResult object that references the asynchronous Socket object creation.

Excepciones

Se requiere Windows NT para este método.Windows NT is required for this method.

El socket receptor no realiza escuchas de conexiones.The accepting socket is not listening for connections. Debe llamar a Bind(EndPoint) y a Listen(Int32) antes de llamar a BeginAccept(AsyncCallback, Object).You must call Bind(EndPoint) and Listen(Int32) before calling BeginAccept(AsyncCallback, Object).

o bien-or- El socket aceptado se encuentra enlazado.The accepted socket is bound.

Error al intentar acceder al socket.An error occurred when attempting to access the socket.

Ejemplos

En el ejemplo de código siguiente se abre un socket y se acepta una conexión asincrónica.The following code example opens a socket and accepts an asynchronous connection. En este ejemplo, el socket acepta los 10 bytes iniciales de datos y el acceptSocket parámetro es null, que obliga al BeginAccept método a crear el socket aceptado.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. El delegado de devolución de llamada muestra el número de bytes recibidos y los datos en la consola.The number of bytes received and the data are displayed on the console by the callback delegate. Vea BeginReceive para obtener una descripción de cómo se reciben los datos restantes.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);
}

Comentarios

Los protocolos orientados a la conexión BeginAccept pueden utilizar el método para procesar asincrónicamente los intentos de conexión entrantes.Connection-oriented protocols can use the BeginAccept method to asynchronously process incoming connection attempts. Aceptar conexiones de forma asincrónica le permite enviar y recibir datos en un subproceso de ejecución independiente.Accepting connections asynchronously gives you the ability to send and receive data within a separate execution thread. Esta sobrecarga permite especificar el socket aceptado en el acceptSocket parámetro.This overload allows you to specify the accepted socket in the acceptSocket parameter. Si este parámetro es null, el BeginAccept método crea el socket aceptado.If this parameter is null, the accepted socket is created by the BeginAccept method. Puede especificar el número de bytes que se van a aceptar en la transferencia inicial receiveSize en el parámetro.You can specify the number of bytes to accept in the initial transfer in the receiveSize parameter.

Antes de llamar BeginAccept al método, debe Listen llamar al método para escuchar y poner en cola las solicitudes de conexión entrantes.Before calling the BeginAccept method, you must call the Listen method to listen for and queue incoming connection requests.

Debe crear un método de devolución de llamada que implemente el AsyncCallback delegado y pasar su nombre BeginAccept al método.You must create a callback method that implements the AsyncCallback delegate and pass its name to the BeginAccept method. Para ello, como mínimo, debe pasar el objeto de escucha Socket a BeginAccept a través del state parámetro.To do this, at the very minimum, you must pass the listening Socket object to BeginAccept through the state parameter. Si la devolución de llamada necesita más información, puede crear una clase pequeña para contener Socket y la otra información necesaria.If your callback needs more information, you can create a small class to hold the Socket and the other required information. Pase una instancia de esta clase al BeginAccept método a través del state parámetro.Pass an instance of this class to the BeginAccept method through the state parameter.

El método de devolución de llamada EndAccept debe invocar el método.Your callback method should invoke the EndAccept method. Cuando la aplicación llama BeginAccepta, el sistema normalmente usa un subproceso independiente para ejecutar el método de devolución de EndAccept llamada especificado y se bloquea hasta que se recupera una conexión pendiente.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.

EndAcceptDevuelve un nuevo Socket objeto que puede usar para enviar y recibir datos con el host remoto.EndAccept returns a new Socket object that you can use to send and receive data with the remote host. No puede usar este devuelto Socket para aceptar conexiones adicionales de la cola de conexión.You cannot use this returned Socket to accept any additional connections from the connection queue. Si desea que el subproceso original se bloquee después de BeginAccept llamar al método WaitHandle.WaitOne, use.If you want the original thread to block after you call the BeginAccept method, use WaitHandle.WaitOne. Llame al método Set en un ManualResetEvent en el método de devolución de llamada cuando desee que el subproceso original continúe ejecutándose.Call the Set method on a ManualResetEvent in the callback method when you want the original thread to continue executing.

El sistema también puede usar el subproceso que realiza la llamada para invocar el método de devolución de llamada.The system may also use the calling thread to invoke the callback method. En este caso, la CompletedSynchronously propiedad del devuelto IAsyncResult se establecerá para indicar que el BeginAccept método se completó sincrónicamente.In this case, the CompletedSynchronously property on the returned IAsyncResult will be set to indicate that the BeginAccept method completed synchronously.

Para obtener información adicional sobre cómo escribir métodos de devolución de llamada, vea calcular las referencias de un delegado como método de devolución de llamada.For additional information on writing callback methods, see Marshaling a Delegate as a Callback Method.

Para cancelar una llamada pendiente al BeginAccept método, cierre el. SocketTo cancel a pending call to the BeginAccept method, close the Socket. Cuando se llama al BeginAccept métodomientrasunaoperaciónasincrónicaestáencurso,sellamaaladevolucióndellamadaproporcionadaalmétodo.CloseWhen the Close method is called while an asynchronous operation is in progress, the callback provided to the BeginAccept method is called. Una llamada subsiguiente al EndAccept método producirá una excepción ObjectDisposedException para indicar que la operación se ha cancelado.A subsequent call to the EndAccept method will throw an ObjectDisposedException to indicate that the operation has been cancelled.

Nota

Puede utilizar la RemoteEndPoint propiedad del objeto devuelto Socket para identificar la dirección de red y el número de puerto del host remoto.You can use the RemoteEndPoint property of the returned Socket object to identify the remote host's network address and port number.

Nota

Si recibe un SocketException, utilice la SocketException.ErrorCode propiedad para obtener el código de error específico.If you receive a SocketException, use the SocketException.ErrorCode property to obtain the specific error code. Después de obtener este código, consulte la documentación del código de error de la API de Windows Sockets versión 2 para obtener una descripción detallada del error.After you have obtained this code, refer to the Windows Sockets version 2 API error code documentation for a detailed description of the error.

Nota

Este miembro genera información de seguimiento cuando se habilita el seguimiento de red en la aplicación.This member outputs trace information when you enable network tracing in your application. Para obtener más información, consulte seguimiento de red en el .NET Framework.For more information, see Network Tracing in the .NET Framework.

Nota

El contexto de ejecución (el contexto de seguridad, el usuario suplantado y el contexto de llamada) se almacena en caché Socket para los métodos asincrónicos.The execution context (the security context, the impersonated user, and the calling context) is cached for the asynchronous Socket methods. Después del primer uso de un contexto determinado (un Socket método asincrónico concreto, una instancia específica Socket y una devolución de llamada específica), los usos posteriores de ese contexto verán una mejora del rendimiento.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.

Consulte también:

Se aplica a