TcpListener Klasse

Definition

Namespace:

System.Net.Sockets

Assembly:

System.Net.Sockets.dll

Quelle:

TCPListener.cs

Überwacht Verbindungen von TCP-Netzwerkclients.

public ref class TcpListener : IDisposable

public class TcpListener : IDisposable

type TcpListener = class
    interface IDisposable

Public Class TcpListener
Implements IDisposable

Vererbung

Object

TcpListener

Implementiert

IDisposable

Beispiele

Im folgenden Codebeispiel wird ein TcpListenererstellt.

#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

Ein Clientbeispiel finden Sie unter TcpClient .

Hinweise

Die TcpListener -Klasse stellt einfache Methoden bereit, mit denen eingehende Verbindungsanforderungen im blockierenden synchronen Modus überwacht und akzeptiert werden. Sie können entweder ein TcpClient oder ein Socket verwenden, um eine Verbindung mit einem TcpListenerherzustellen. Create eineTcpListener, die eine IPEndPointlokale IP-Adresse und Portnummer oder nur eine Portnummer verwendet. Geben Sie Any für die lokale IP-Adresse und 0 für die lokale Portnummer an, wenn Der zugrunde liegende Dienstanbieter diese Werte für Sie zuweisen soll. Wenn Sie dies tun, können Sie die LocalEndpoint -Eigenschaft verwenden, um die zugewiesenen Informationen zu identifizieren, nachdem der Socket verbunden wurde.

Verwenden Sie die Start -Methode, um auf eingehende Verbindungsanforderungen zu lauschen. Start stellt eingehende Verbindungen in die Warteschlange, bis Sie entweder die -Methode aufrufen oder in eine Stop Warteschlange eingereiht MaxConnectionshaben. Verwenden Sie entweder AcceptSocket oder AcceptTcpClient , um eine Verbindung aus der Warteschlange für eingehende Verbindungsanforderungen abzurufen. Diese beiden Methoden werden blockiert. Wenn Sie eine Blockierung vermeiden möchten, können Sie zuerst mit der Pending -Methode ermitteln, ob Verbindungsanforderungen in der Warteschlange verfügbar sind.

Rufen Sie die Stop -Methode auf, um die TcpListenerzu schließen.

Hinweis

Die Stop -Methode schließt keine akzeptierten Verbindungen. Sie sind dafür verantwortlich, diese separat zu schließen.

Konstruktoren

TcpListener(Int32)	Veraltet. Initialisiert eine neue Instanz der TcpListener-Klasse, die den angegebenen Anschluss überwacht.
TcpListener(IPAddress, Int32)	Initialisiert eine neue Instanz der TcpListener-Klasse, die die eingehenden Verbindungsversuche mit der angegebenen lokalen IP-Adresse und Anschlussnummer überwacht.
TcpListener(IPEndPoint)	Initialisiert eine neue Instanz der TcpListener-Klasse mit dem angegebenen lokalen Endpunkt.

Eigenschaften

Active	Ruft einen Wert ab, der angibt, ob TcpListener Clientverbindungen aktiv überwacht.
ExclusiveAddressUse	Ruft einen Boolean-Wert ab, der angibt, ob der TcpListener das Überwachen eines bestimmten Anschlusses durch nur einen einzigen zugrunde liegenden Socket zulässt, oder legt diesen fest.
LocalEndpoint	Ruft den zugrunde liegenden EndPoint des aktuellen TcpListener ab.
Server	Ruft den zugrunde liegenden Netzwerk-Socket ab.

Methoden

AcceptSocket()	Nimmt eine ausstehende Verbindungsanforderung an.
AcceptSocketAsync()	Nimmt eine ausstehende Aufforderung zum Aufbau einer Verbindung als asynchroner Vorgang an.
AcceptSocketAsync(CancellationToken)	Akzeptiert eine ausstehende Verbindungsanforderung als abbruchfähigen asynchronen Vorgang.
AcceptTcpClient()	Nimmt eine ausstehende Verbindungsanforderung an.
AcceptTcpClientAsync()	Nimmt eine ausstehende Aufforderung zum Aufbau einer Verbindung als asynchroner Vorgang an.
AcceptTcpClientAsync(CancellationToken)	Akzeptiert eine ausstehende Verbindungsanforderung als abbruchfähigen asynchronen Vorgang.
AllowNatTraversal(Boolean)	Aktiviert oder deaktiviert die NAT-Überquerung (Netzwerkadressenübersetzung) für eine TcpListener-Instanz.
BeginAcceptSocket(AsyncCallback, Object)	Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung anzunehmen.
BeginAcceptTcpClient(AsyncCallback, Object)	Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung anzunehmen.
Create(Int32)	Erstellt eine neue auf dem angegebenen Port lauschende TcpListener-Instanz.
Dispose()	Gibt alle von der aktuellen Instanz TcpListener verwendeten Ressourcen frei
EndAcceptSocket(IAsyncResult)	Nimmt asynchron einen eingehenden Verbindungsversuch an und erstellt einen neuen Socket zum Behandeln der Remotehostkommunikation.
EndAcceptTcpClient(IAsyncResult)	Nimmt asynchron einen eingehenden Verbindungsversuch an und erstellt einen neuen TcpClient zum Behandeln der Remotehostkommunikation.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
Pending()	Bestimmt, ob ausstehende Verbindungsanforderungen vorliegen.
Start()	Beginnt die Überwachung von eingehenden Verbindungsanforderungen.
Start(Int32)	Beginnt die Überwachung eingehender Verbindungsanforderungen mit einer maximalen Anzahl ausstehender Verbindungen.
Stop()	Schließt den Listener.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Weitere Informationen

• TcpClient