AcceptTcpClient Method
Collapse the table of content
Expand the table of content
This documentation is archived and is not being maintained.

TcpListener.AcceptTcpClient Method

Accepts a pending connection request

[Visual Basic]
Public Function AcceptTcpClient() As TcpClient
[C#]
public TcpClient AcceptTcpClient();
[C++]
public: TcpClient* AcceptTcpClient();
[JScript]
public function AcceptTcpClient() : TcpClient;

Return Value

A TcpClient used to send and receive data.

Exceptions

Exception Type Condition
InvalidOperationException The listener has not been started with a call to Start.

Remarks

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

Use TcpClient.GetStream 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.

Example

[Visual Basic, C#, C++] In the following example, AcceptTcpClient is used to return a TcpClient. This TcpClient is used to communicate with the newly connected client.

[Visual Basic] 
' The following function creates a TcpServer that connects to  
' the specified port (13000).
' Refer to the related client in the TcpClient class. 

Public Shared Sub Main()
   
   Try
      ' Set the TcpListener on port 13000.
      Dim port As Int32 = 13000
      Dim server As New TcpListener(port)
      
      ' Start listening for client requests.
      server.Start()
      
      ' Buffer for reading data
      Dim bytes(1024) As [Byte]
      Dim data As [String] = Nothing
      
      ' 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.
         Dim client As TcpClient = server.AcceptTcpClient()
         Console.WriteLine("Connected!")
         
         data = Nothing
         
         ' Get a stream object for reading and writing
         Dim stream As NetworkStream = client.GetStream()
         
         Dim i As Int32
         
         ' Loop to receive all the data sent by the client.
         i = stream.Read(bytes, 0, bytes.Length)
         While (i <> 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()
            
            Dim msg As [Byte]() = System.Text.Encoding.ASCII.GetBytes(data)
            
            ' Send back a response.
            stream.Write(msg, 0, msg.Length)
            Console.WriteLine([String].Format("Sent: {0}", data))
           
            i = stream.Read(bytes, 0, bytes.Length)

         End While
         
         ' Shutdown and end connection
         client.Close()
      End While
   Catch e As SocketException
      Console.WriteLine("SocketException: {0}", e)
   End Try
   
   Console.WriteLine(ControlChars.Cr + "Hit enter to continue...")
   Console.Read()
End Sub 'Main

[C#] 
/**
 * The following function creates a TcpServer that connects to  
 * the specified port (13000).Any TcpClient that wants to use this server
 * has to explicitly connect to an address obtained by the combination of
 * the sever on which this TCpServer is runnig and the port 13000. 
 * This TcpServer simply echoes back the message sent by the TcpClient, after
 * translating it into uppercase. 
 * Refer to the related client in the TcpClient class. 
 **/ 
public static void Main()
{    
 
  try
  {
    // Set the TcpListener on port 13000.
    Int32 port = 13000;
    TcpListener server = new TcpListener(port);

    // Start listening for client requests.
    server.Start();
       
    // Buffer for reading data
    Byte[] bytes = new Byte[256];
    String data = null;

    // 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 = null;

      // 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();

        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
      client.Close();
    }
  }
  catch(SocketException e)
  {
    Console.WriteLine("SocketException: {0}", e);
  }
    
  Console.WriteLine("\nHit enter to continue...");
  Console.Read();
}   

[C++] 
/**
 * The following function creates a TcpServer that connects to  
 * the specified port (13000).Any TcpClient that wants to use this server
 * has to explicitly connect to an address obtained by the combination of
 * the sever on which this TCpServer is runnig and the port 13000. 
 * This TcpServer simply echoes back the message sent by the TcpClient, after
 * translating it into uppercase. 
 * Refer to the related client in the TcpClient class. 
 **/ 
int main()
{    

   try
   {
      // Set the TcpListener on port 13000.
      Int32 port = 13000;
      TcpListener* server = new TcpListener(port);

      // Start listening for client requests.
      server->Start();

      // Buffer for reading data
      Byte bytes[] = new Byte[256];
      String* data = 0;

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

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

         data = 0;

         // 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(S"Received: {0}", data));

            // Process the data sent by the client.
            data = data->ToUpper();

            Byte msg[] = System::Text::Encoding::ASCII->GetBytes(data);

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

         // Shutdown and end connection
         client->Close();
      }
   }
   catch(SocketException* e)
   {
      Console::WriteLine(S"SocketException: {0}", e);
   }

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

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family, .NET Compact Framework

See Also

TcpListener Class | TcpListener Members | System.Net.Sockets Namespace | TcpClient | AcceptSocket | Socket | NetworkStream

Show:
© 2016 Microsoft