Information
The topic you requested is included in another documentation set. For convenience, it's displayed below. Choose Switch to see the topic in its original location.

TcpListener.Start Method

Starts listening for incoming connection requests.

[Visual Basic]
Public Sub Start()
[C#]
public void Start();
[C++]
public: void Start();
[JScript]
public function Start();

Exceptions

Exception Type Condition
SocketException Use SocketException.ErrorCode to obtain the specific error code. Once you have obtained this code, you can refer to the Windows Socket Version 2 API error code documentation in MSDN for a detailed description of the error.

Remarks

The Start method initializes the underlying Socket, binds it to a local endpoint, and listens for incoming connection attempts. If a connection request is received, Start will queue the request and continue listening for additional requests until you call the Stop method. If TcpListener receives a connection request after it has already queued the maximum number of connections it will throw a SocketException.

To remove a connection from the incoming connection queue, use either the AcceptTcpClient method or the AcceptSocket method. The AcceptTcpClient method will remove a connection from the queue and return a TcpClient that you can use to send and receive data. The AcceptSocket method will return a Socket that you can use to do the same. If your application only requires basic blocking synchronous I/O, use AcceptTcpClient. For more detailed behavioral control, use AcceptSocket. Both of these methods block execution until a connection request is available in the queue. Use the Pending method if you want to be sure a connection is available before attempting to accept.

Use the Stop method to close the TcpListener and stop listening. You are responsible for closing your accepted connections separately.

Example

[Visual Basic, C#, C++] The following example demonstrates how Start is used to listen for incoming client connection attempts.

[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 | Listen | Bind | AcceptTcpClient | AcceptSocket | Pending | Stop

Was this page helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2015 Microsoft