TcpListener.AcceptTcpClient-Methode

Akzeptiert eine ausstehende Verbindungsanforderung.

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

Syntax

'Declaration
Public Function AcceptTcpClient As TcpClient
'Usage
Dim instance As TcpListener
Dim returnValue As TcpClient

returnValue = instance.AcceptTcpClient

public TcpClient AcceptTcpClient ()

public:
TcpClient^ AcceptTcpClient ()

public TcpClient AcceptTcpClient ()

public function AcceptTcpClient () : TcpClient

Rückgabewert

Ein TcpClient zum Senden und Empfangen von Daten.

Ausnahmen

Hinweise

AcceptTcpClient ist eine blockierende Methode, die einen TcpClient zum Senden und Empfangen von Daten zurückgibt. Wenn Sie das Blockieren vermeiden möchten, können Sie mit der Pending-Methode bestimmen, ob sich Verbindungsanforderungen in der Warteschlange für eingehende Verbindungen befinden.

Mit der TcpClient.GetStream-Methode können Sie den zugrunde liegenden NetworkStream des zurückgegebenen TcpClient abrufen. Der NetworkStream stellt Methoden für das Senden an bzw. Empfangen mit dem Remotehost bereit. Rufen Sie immer die Close-Methode des Sockets auf, wenn Sie den TcpClient nicht mehr benötigen. Wenn Ihnen die von TcpClient gebotene Flexibilität nicht ausreicht, empfiehlt sich die Verwendung von AcceptSocket.

Beispiel

Im folgenden Codebeispiel wird die AcceptTcpClient-Methode verwendet, um einen TcpClient zurückzugeben. TcpClient wird zum Kommunizieren mit dem neu verbundenen Client verwendet.

' 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

     // Create a socket and connect with a remote host.
IPHostEntry myIpHostEntry = Dns.Resolve("www.contoso.com");
IPEndPoint myIpEndPoint = new IPEndPoint(myIpHostEntry.AddressList[0], 1001);

     Socket mySocket = new Socket(myIpEndPoint.Address.AddressFamily,
                                SocketType.Stream,
                                       ProtocolType.Tcp);
     try{
          mySocket.Connect(myIpEndPoint);
     
          
          // Create the NetworkStream for communicating with the remote host.
          NetworkStream myNetworkStream;
          
          if (networkStreamOwnsSocket){
               myNetworkStream = new NetworkStream(mySocket, true);          
          }
          else{
               myNetworkStream = new NetworkStream(mySocket);     
          }

         
          // Check to see if this NetworkStream is writable.
          if (myNetworkStream.CanWrite){
             
               byte[] myWriteBuffer = Encoding.ASCII.GetBytes("Are you receiving this message?");
               myNetworkStream.Write(myWriteBuffer, 0, myWriteBuffer.Length);
          }
          else{
               Console.WriteLine("Sorry.  You cannot write to this NetworkStream.");  
          }


         
          // Check to see if this NetworkStream is readable.
          if(myNetworkStream.CanRead){
              byte[] myReadBuffer = new byte[1024];
              StringBuilder myCompleteMessage = new StringBuilder();
              int numberOfBytesRead = 0;

              // Incoming message may be larger than the buffer size.
              do{
                   numberOfBytesRead = myNetworkStream.Read(myReadBuffer, 0, myReadBuffer.Length);

                   myCompleteMessage.AppendFormat("{0}", Encoding.ASCII.GetString(myReadBuffer, 0, numberOfBytesRead));
                                   
              }
              while(myNetworkStream.DataAvailable);

              // Print out the received message to the console.
              Console.WriteLine("You received the following message : " +
                                           myCompleteMessage);
          }
          else{
               Console.WriteLine("Sorry.  You cannot read from this NetworkStream.");
          }



          // Close the NetworkStream
          myNetworkStream.Close();

     }
     catch (Exception exception){
          Console.WriteLine("Exception Thrown: " + exception.ToString());
     }
     

  }

/**
 * 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 = gcnew TcpListener( port );
      
      // Start listening for client requests.
      server->Start();
      
      // 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
         client->Close();
      }
   }
   catch ( SocketException^ e ) 
   {
      Console::WriteLine( "SocketException: {0}", e );
   }

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

/**
* 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(String[] args)
{
    try {
        // Set the TcpListener on port 13000.
        int port = 13000;
        TcpListener server = new TcpListener(port);

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

        // Buffer for reading data
        ubyte bytes[] = new ubyte[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();
            int 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.get_ASCII().GetString(
                    bytes, 0, i);
                Console.WriteLine(String.Format("Received: {0}", data));

                // Process the data sent by the client.
                data = data.ToUpper();
                ubyte msg[] = System.Text.Encoding.get_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();
} //main

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

TcpListener-Klasse
TcpListener-Member
System.Net.Sockets-Namespace
TcpClient-Klasse
AcceptSocket
Socket-Klasse
NetworkStream-Klasse