TcpListener::AcceptTcpClient Method ()


The .NET API Reference documentation has a new home. Visit the .NET API Browser on to see the new experience.

Accepts a pending connection request.

Namespace:   System.Net.Sockets
Assembly:  System (in System.dll)

TcpClient^ AcceptTcpClient()

Return Value

Type: System.Net.Sockets::TcpClient^

A TcpClient used to send and receive data.

Exception Condition

The listener has not been started with a call to Start.


Use the SocketException::ErrorCode property to obtain the specific error code. When you have obtained this code, you can refer to the Windows Sockets version 2 API error code documentation in MSDN for a detailed description of the error.

AcceptTcpClient is a blocking method that returns a TcpClient that you can use to send and receive data. Use the Pending method to determine if connection requests are available in the incoming connection queue if you want to avoid blocking.

Use the TcpClient::GetStream method to obtain the underlying NetworkStream of the returned TcpClient. The NetworkStream will provide you with methods for sending and receiving with the remote host. When you are through with the TcpClient, be sure to call its Close method. If you want greater flexibility than a TcpClient offers, consider using AcceptSocket.


This member outputs trace information when you enable network tracing in your application. For more information, see Network Tracing in the .NET Framework.

In the following code example, the AcceptTcpClient method is used to return a TcpClient. This TcpClient is used to communicate with the newly connected client.

* This program shows how to use the TcpListener class. 
* It creates a TcpListener that listens on the specified port (13000). 
* To run this program at the command line you enter:
* cs_tcpserver
* Any TcpClient that wants to use this server
* has to explicitly connect to an address obtained by the combination of
* the server on which this TcpServer is running and the port 13000. 
* This TcpServer simply echoes back the message sent by the TcpClient, after
* translating it into uppercase. 

#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Net;
using namespace System::Net::Sockets;
using namespace System::Text;

int main()

      // Set the TcpListener on port 13000.
      Int32 port = 13000;
      TcpListener^ server = gcnew TcpListener(IPAddress::Any, port);

      // Start listening for client requests.

      // Buffer for reading data
      array<Byte>^bytes = gcnew array<Byte>(256);
      String^ data = nullptr;

      // Enter the listening loop.
      while ( true )
         Console::Write( "Waiting for a connection... " );

         // Perform a blocking call to accept requests.
         // You could also user server.AcceptSocket() here.
         TcpClient^ client = server->AcceptTcpClient();
         Console::WriteLine( "Connected!" );
         data = nullptr;

         // Get a stream object for reading and writing
         NetworkStream^ stream = client->GetStream();
         Int32 i;

         // Loop to receive all the data sent by the client.
         while ( (i = stream->Read( bytes, 0, bytes->Length )) != 0 )

            // Translate data bytes to a ASCII string.
            data = System::Text::Encoding::ASCII->GetString( bytes, 0, i );
            Console::WriteLine( String::Format( "Received: {0}", data ) );

            // Process the data sent by the client.
            data = data->ToUpper();
            array<Byte>^msg = System::Text::Encoding::ASCII->GetBytes( data );

            // Send back a response.
            stream->Write( msg, 0, msg->Length );
            Console::WriteLine( String::Format( "Sent: {0}", data ) );

         // Shutdown and end connection
   catch ( SocketException^ e ) 
      Console::WriteLine( "SocketException: {0}", e );

   Console::WriteLine( "\nHit enter to continue..." );

.NET Framework
Available since 1.1
Return to top