TcpListener.AcceptTcpClient Metoda

Definicja

Przestrzeń nazw:

System.Net.Sockets

Zestaw:

System.Net.Sockets.dll

Źródło:

TCPListener.cs

Akceptuje oczekujące żądanie połączenia.

public:
 System::Net::Sockets::TcpClient ^ AcceptTcpClient();

public System.Net.Sockets.TcpClient AcceptTcpClient ();

member this.AcceptTcpClient : unit -> System.Net.Sockets.TcpClient

Public Function AcceptTcpClient () As TcpClient

Zwraca

TcpClient

Służy TcpClient do wysyłania i odbierania danych.

Wyjątki

InvalidOperationException

Odbiornik nie został uruchomiony z wywołaniem metody Start().

SocketException

Użyj właściwości , ErrorCode aby uzyskać określony kod błędu. Po uzyskaniu tego kodu możesz zapoznać się z dokumentacją kodu błędu interfejsu API gniazd systemu Windows w wersji 2 , aby uzyskać szczegółowy opis błędu.

Przykłady

W poniższym przykładzie AcceptTcpClient kodu metoda jest używana do zwracania elementu TcpClient. Służy do TcpClient komunikowania się z nowo połączonym klientem.

/**
* 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()
{
   try
   {
      
      // Set the TcpListener on port 13000.
      Int32 port = 13000;
      TcpListener^ server = gcnew TcpListener(IPAddress::Any, 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 use 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 sample is intended to demonstrate how to use a
* TcpListener for synchronous communcation with a TCP client
* It creates a TcpListener that listens on the specified port (13000).
* Any TCP client that wants to use this TcpListener has to explicitly connect
* to an address obtained by the combination of the server
* on which this TcpListener is running and the port 13000.
* This TcpListener simply echoes back the message sent by the client
* after translating it into uppercase.
* Refer to the related client in the TcpClient class.
*/
using System;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;

public class TcpListenerSample
{

    static void Main(string[] args)
    {
        try
        {
            // set the TcpListener on port 13000
            int port = 13000;
            TcpListener server = new TcpListener(IPAddress.Any, port);

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

            // Buffer for reading data
            byte[] bytes = new byte[1024];
            string data;

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

                // Perform a blocking call to accept requests.
                // You could also use server.AcceptSocket() here.
                TcpClient client = server.AcceptTcpClient();
                Console.WriteLine("Connected!");

                // Get a stream object for reading and writing
                NetworkStream stream = client.GetStream();

                int i;

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

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

                    i = stream.Read(bytes, 0, bytes.Length);
                }

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

        Console.WriteLine("Hit enter to continue...");
        Console.Read();
    }
}

' The following sample is intended to demonstrate how to use a
' TcpListener for synchronous communcation with a TCP client
' It creates a TcpListener that connects to the specified port (13000).
' Any TCP client that wants to use this TcpListener has to explicitly connect 
' to an address obtained by the combination of the server
' on which this TcpListener is running and the port 13000.
' This TcpListener simply echoes back the message sent by the client
' after translating it into uppercase. 
' Refer to the related client in the TcpClient class. 
'/


Imports System.IO
Imports System.Net
Imports System.Net.Sockets
Imports System.Text

 _

Class MyTcpListener
   
   Public Shared Sub Main()
      
      Try
         ' Set the TcpListener on port 13000.
         Dim port As Int32 = 13000
         Dim server As New TcpListener(IPAddress.Any, 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 use 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
End Class

Uwagi

AcceptTcpClient to metoda blokująca, która zwraca TcpClient wartość, której można użyć do wysyłania i odbierania danych. Pending Użyj metody , aby określić, czy żądania połączenia są dostępne w kolejce połączeń przychodzących, jeśli chcesz uniknąć blokowania.

TcpClient.GetStream Użyj metody , aby uzyskać podstawę NetworkStream zwróconego TcpClientobiektu . Usługa NetworkStream udostępnia metody wysyłania i odbierania za pomocą hosta zdalnego. Jeśli korzystasz z elementu TcpClient, pamiętaj, aby wywołać jego Close metodę. Jeśli potrzebujesz większej TcpClient elastyczności niż oferty, rozważ użycie metody AcceptSocket.

Uwaga

Ten element członkowski generuje informacje ze śledzenia pod warunkiem włączenia funkcji śledzenia sieci w aplikacji. Aby uzyskać więcej informacji, zobacz Śledzenie sieci w .NET Framework.

Zobacz też

• TcpClient
• AcceptSocket()
• Socket
• NetworkStream