TcpListener.BeginAcceptTcpClient(AsyncCallback, Object) Método

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.

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

Parámetros

callback
AsyncCallback

Delegado de AsyncCallback que hace referencia al método que se invocará cuando la operación se complete.An AsyncCallback delegate that references the method to invoke when the operation is complete.

state
Object

Objeto definido por el usuario que contiene información sobre la operación de aceptación.A user-defined object containing information about the accept operation. Este objeto se pasa al delegado de callback cuando la operación se completa.This object is passed to the callback delegate when the operation is complete.

Devoluciones

IAsyncResult

Interfaz IAsyncResult que hace referencia a la creación asincrónica del objeto TcpClient.An IAsyncResult that references the asynchronous creation of the TcpClient.

Excepciones

Se ha producido un error al intentar obtener acceso al socket.An error occurred while attempting to access the socket.

El Socket se ha cerrado.The Socket has been closed.

Ejemplos

En el ejemplo de código siguiente se muestra el uso del BeginAcceptTcpClient método para crear y conectar un socket.The following code example demonstrates the use of the BeginAcceptTcpClient method to create and connect a socket. El delegado de devolución de llamada llama al EndAcceptTcpClient método para finalizar la solicitud asincrónica.The callback delegate calls the EndAcceptTcpClient method to end the asynchronous request.

    // Thread signal.
public:
    static ManualResetEvent^ TcpClientConnected;

    // Accept one client connection asynchronously.
public:
    static void DoBeginAcceptTcpClient(TcpListener^ listener)
    {
        // Set the event to nonsignaled state.
        TcpClientConnected->Reset();

        // Start to listen for connections from a client.
        Console::WriteLine("Waiting for a connection...");

        // Accept the connection.
        // BeginAcceptSocket() creates the accepted socket.
        listener->BeginAcceptTcpClient(
            gcnew AsyncCallback(DoAcceptTcpClientCallback),
            listener);

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

    // Process the client connection.
public:
    static void DoAcceptTcpClientCallback(IAsyncResult^ result)
    {
        // Get the listener that handles the client request.
        TcpListener^ listener = (TcpListener^) result->AsyncState;

        // End the operation and display the received data on
        // the console.
        TcpClient^ client = listener->EndAcceptTcpClient(result);

        // Process the connection here. (Add the client to a
        // server table, read data, etc.)
        Console::WriteLine("Client connected completed");

        // Signal the calling thread to continue.
        TcpClientConnected->Set();

    }
// Thread signal.
public static ManualResetEvent tcpClientConnected =
    new ManualResetEvent(false);

// Accept one client connection asynchronously.
public static void DoBeginAcceptTcpClient(TcpListener
    listener)
{
    // Set the event to nonsignaled state.
    tcpClientConnected.Reset();

    // Start to listen for connections from a client.
    Console.WriteLine("Waiting for a connection...");

    // Accept the connection.
    // BeginAcceptSocket() creates the accepted socket.
    listener.BeginAcceptTcpClient(
        new AsyncCallback(DoAcceptTcpClientCallback),
        listener);

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

// Process the client connection.
public static void DoAcceptTcpClientCallback(IAsyncResult ar)
{
    // Get the listener that handles the client request.
    TcpListener listener = (TcpListener) ar.AsyncState;

    // End the operation and display the received data on
    // the console.
    TcpClient client = listener.EndAcceptTcpClient(ar);

    // Process the connection here. (Add the client to a
    // server table, read data, etc.)
    Console.WriteLine("Client connected completed");

    // Signal the calling thread to continue.
    tcpClientConnected.Set();
}
' Thread signal.
Public Shared tcpClientConnected As New ManualResetEvent(False)


' Accept one client connection asynchronously.
Public Shared Sub DoBeginAcceptTcpClient(listener As TcpListener)
   ' Set the event to nonsignaled state.
   tcpClientConnected.Reset()
   
   ' Start to listen for connections from a client.
   Console.WriteLine("Waiting for a connection...")
   
   ' Accept the connection. 
   ' BeginAcceptSocket() creates the accepted socket.
   listener.BeginAcceptTcpClient(New AsyncCallback(AddressOf DoAcceptTcpClientCallback), listener)
   
   ' Wait until a connection is made and processed before 
   ' continuing.
   tcpClientConnected.WaitOne()
End Sub


' Process the client connection.
Public Shared Sub DoAcceptTcpClientCallback(ar As IAsyncResult)
   ' Get the listener that handles the client request.
   Dim listener As TcpListener = CType(ar.AsyncState, TcpListener)
   
   ' End the operation and display the received data on 
   ' the console.
   Dim client As TcpClient = listener.EndAcceptTcpClient(ar)
   
   ' Process the connection here. (Add the client to a
   ' server table, read data, etc.)
   Console.WriteLine("Client connected completed")
   
   ' Signal the calling thread to continue.
   tcpClientConnected.Set()
End Sub
 

Comentarios

La operación asincrónica BeginAcceptTcpClient se debe completar llamando al EndAcceptTcpClient método.The asynchronous BeginAcceptTcpClient operation must be completed by calling the EndAcceptTcpClient method. Normalmente, el delegado invoca el método callback .Typically, the method is invoked by the callback delegate.

Este método no se bloquea hasta que se completa la operación.This method does not block until the operation completes. Para bloquear hasta que finalice la operación, use el AcceptTcpClient método.To block until the operation completes, use the AcceptTcpClient method.

Para obtener información detallada sobre el uso del modelo de programación asincrónica, vea llamar a métodos sincrónicos de forma asincrónica.For detailed information about using the asynchronous programming model, see Calling Synchronous Methods Asynchronously.

Nota

Si recibe un SocketException , use la SocketException.ErrorCode propiedad para obtener el código de error específico y 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.If you receive a SocketException, use the SocketException.ErrorCode property to obtain the specific error code and 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.

Se aplica a