TcpListener Klasa

Definicja

Przestrzeń nazw:

System.Net.Sockets

Zestaw:

System.Net.Sockets.dll

Źródło:

TCPListener.cs

Nasłuchuje połączeń z klientów sieci TCP.

public ref class TcpListener : IDisposable

public class TcpListener : IDisposable

type TcpListener = class
    interface IDisposable

Public Class TcpListener
Implements IDisposable

Dziedziczenie

Object

TcpListener

Implementuje

IDisposable

Przykłady

Poniższy przykład kodu tworzy obiekt TcpListener.

#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Net;
using namespace System::Net::Sockets;
using namespace System::Text;
using namespace System::Threading;
void main()
{
   try
   {
      
      // Set the TcpListener on port 13000.
      Int32 port = 13000;
      IPAddress^ localAddr = IPAddress::Parse( "127.0.0.1" );
      
      // TcpListener* server = new TcpListener(port);
      TcpListener^ server = gcnew TcpListener( localAddr,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 ) )
         {
            
            // Translate data bytes to a ASCII String*.
            data = Text::Encoding::ASCII->GetString( bytes, 0, i );
            Console::WriteLine( "Received: {0}", data );
            
            // Process the data sent by the client.
            data = data->ToUpper();
            array<Byte>^msg = Text::Encoding::ASCII->GetBytes( data );
            
            // Send back a response.
            stream->Write( msg, 0, msg->Length );
            Console::WriteLine( "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();
}

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;

class MyTcpListener
{
  public static void Main()
  {
    TcpListener server = null;
    try
    {
      // Set the TcpListener on port 13000.
      Int32 port = 13000;
      IPAddress localAddr = IPAddress.Parse("127.0.0.1");

      // TcpListener server = new TcpListener(port);
      server = new TcpListener(localAddr, 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 use server.AcceptSocket() here.
        using 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.ASCII.GetString(bytes, 0, i);
          Console.WriteLine("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("Sent: {0}", data);
        }
      }
    }
    catch(SocketException e)
    {
      Console.WriteLine("SocketException: {0}", e);
    }
    finally
    {
      server.Stop();
    }

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

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

Class MyTcpListener

    Public Shared Sub Main()

    Dim server As TcpListener
    server=nothing
        Try
            ' Set the TcpListener on port 13000.
         Dim port As Int32 = 13000
         Dim localAddr As IPAddress = IPAddress.Parse("127.0.0.1")

         server = New TcpListener(localAddr, 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("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("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)
      Finally
         server.Stop()
      End Try
      
      Console.WriteLine(ControlChars.Cr + "Hit enter to continue....")
      Console.Read()
   End Sub

End Class

Zobacz TcpClient przykład klienta.

Uwagi

Klasa TcpListener udostępnia proste metody nasłuchiwania i akceptowania przychodzących żądań połączeń w trybie synchronicznym. Możesz użyć a TcpClient lub , Socket aby nawiązać połączenie z elementem TcpListener. TcpListener Twórca przy użyciu , lokalnego IPEndPointadresu IP i numeru portu lub tylko numeru portu. Określ Any lokalny adres IP i 0 dla lokalnego numeru portu, jeśli chcesz, aby podstawowy dostawca usług przypisył te wartości. Jeśli zdecydujesz się to zrobić, możesz użyć LocalEndpoint właściwości , aby zidentyfikować przypisane informacje, po nawiązaniu połączenia gniazda.

Start Użyj metody , aby rozpocząć nasłuchiwanie przychodzących żądań połączeń. Start spowoduje kolejkę połączeń przychodzących do momentu wywołania Stop metody lub kolejkowania MaxConnections. Użyj polecenia AcceptSocket lub AcceptTcpClient , aby ściągnąć połączenie z kolejki żądań połączeń przychodzących. Te dwie metody będą blokowane. Jeśli chcesz uniknąć blokowania, możesz najpierw użyć Pending metody , aby określić, czy żądania połączenia są dostępne w kolejce.

Wywołaj metodę , Stop aby zamknąć metodę TcpListener.

Uwaga

Metoda Stop nie zamyka żadnych akceptowanych połączeń. Użytkownik jest odpowiedzialny za zamknięcie tych danych oddzielnie.

Konstruktory

TcpListener(Int32)	Przestarzałe. Inicjuje TcpListener nowe wystąpienie klasy, która nasłuchuje na określonym porcie.
TcpListener(IPAddress, Int32)	Inicjuje TcpListener nowe wystąpienie klasy, która nasłuchuje prób połączenia przychodzącego na określonym lokalnym adresie IP i numerze portu.
TcpListener(IPEndPoint)	Inicjuje TcpListener nowe wystąpienie klasy z określonym lokalnym punktem końcowym.

Właściwości

Active	Pobiera wartość wskazującą, czy TcpListener aktywnie nasłuchuje połączeń klienckich.
ExclusiveAddressUse	Pobiera lub ustawia wartość określającą Boolean , czy TcpListener zezwala tylko jednemu bazowemu gniazdu na nasłuchiwanie określonego portu.
LocalEndpoint	Pobiera element bazowy EndPoint bieżącego TcpListenerelementu .
Server	Pobiera podstawową sieć Socket.

Metody

AcceptSocket()	Akceptuje oczekujące żądanie połączenia.
AcceptSocketAsync()	Akceptuje oczekujące żądanie połączenia jako operację asynchroniczną.
AcceptSocketAsync(CancellationToken)	Akceptuje oczekujące żądanie połączenia jako operację asynchroniczną z możliwością anulowania.
AcceptTcpClient()	Akceptuje oczekujące żądanie połączenia.
AcceptTcpClientAsync()	Akceptuje oczekujące żądanie połączenia jako operację asynchroniczną.
AcceptTcpClientAsync(CancellationToken)	Akceptuje oczekujące żądanie połączenia jako operację asynchroniczną z możliwością anulowania.
AllowNatTraversal(Boolean)	Włącza lub wyłącza przechodzenie translatora adresów sieciowych (NAT) w wystąpieniu TcpListener .
BeginAcceptSocket(AsyncCallback, Object)	Rozpoczyna operację asynchroniczną, aby zaakceptować próbę połączenia przychodzącego.
BeginAcceptTcpClient(AsyncCallback, Object)	Rozpoczyna operację asynchroniczną, aby zaakceptować próbę połączenia przychodzącego.
Create(Int32)	Tworzy nowe TcpListener wystąpienie do nasłuchiwania na określonym porcie.
Dispose()	Zwalnia wszystkie zasoby używane przez bieżące TcpListener wystąpienie.
EndAcceptSocket(IAsyncResult)	Asynchronicznie akceptuje próbę połączenia przychodzącego i tworzy nowy Socket do obsługi komunikacji hosta zdalnego.
EndAcceptTcpClient(IAsyncResult)	Asynchronicznie akceptuje próbę połączenia przychodzącego i tworzy nowy TcpClient do obsługi komunikacji hosta zdalnego.
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetType()	Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
Pending()	Określa, czy istnieją oczekujące żądania połączenia.
Start()	Rozpoczyna nasłuchiwanie przychodzących żądań połączeń.
Start(Int32)	Rozpoczyna nasłuchiwanie przychodzących żądań połączeń z maksymalną liczbą oczekujących połączeń.
Stop()	Zamyka odbiornik.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)

Zobacz też

• TcpClient