' 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 'DoBeginAcceptTcpClient


' 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 'DoAcceptTcpClientCallback

// 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:
    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.
static ManualResetEvent* tcpClientConnected = 
    new ManualResetEvent(false);

// Accept one client connection asynchronously.
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(0, 
                        &tcplistener::DoAcceptTcpClientCallback), 
        listener);

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

// Process the client connection.
static void DoAcceptTcpClientCallback(IAsyncResult* ar) 
{
    // Get the listener that handles the client request.
    TcpListener* listener = 
        dynamic_cast<TcpListener*> (ar->AsyncState);

    // Get the new TcpClient.
    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();
}