TcpClient Klasse

Definition

Namespace:

System.Net.Sockets

Assembly:

System.Net.Sockets.dll

Quelle:

TCPClient.cs

Stellt Clientverbindungen für TCP-Netzwerkdienste bereit.

public ref class TcpClient : IDisposable

public class TcpClient : IDisposable

type TcpClient = class
    interface IDisposable

Public Class TcpClient
Implements IDisposable

Vererbung

Object

TcpClient

Implementiert

IDisposable

Beispiele

Im folgenden Codebeispiel wird eine TcpClient Verbindung hergestellt.

void Connect( String^ server, String^ message )
{
   TcpClient^ client = nullptr;
   try
   {
      // Create a TcpClient.
      // Note, for this client to work you need to have a TcpServer 
      // connected to the same address as specified by the server, port
      // combination.
      Int32 port = 13000;
      client = gcnew TcpClient(server, port);
      
      // Translate the passed message into ASCII and store it as a Byte array.
      array<Byte>^data = Text::Encoding::ASCII->GetBytes( message );
      
      // Get a client stream for reading and writing.
      NetworkStream^ stream = client->GetStream();
      
      // Send the message to the connected TcpServer. 
      stream->Write( data, 0, data->Length );

      Console::WriteLine( "Sent: {0}", message );
      
      // Receive the server response.

      // Buffer to store the response bytes.
      data = gcnew array<Byte>(256);

      // String to store the response ASCII representation.
      String^ responseData = String::Empty;
      
      // Read the first batch of the TcpServer response bytes.
      Int32 bytes = stream->Read( data, 0, data->Length );
      responseData = Text::Encoding::ASCII->GetString( data, 0, bytes );
      Console::WriteLine( "Received: {0}", responseData );
      
      // Explicit close is not necessary since TcpClient::Dispose() will be
      // called automatically in finally block.
      // stream->Close();
      // client->Close();
   }
   catch ( ArgumentNullException^ e ) 
   {
      Console::WriteLine( "ArgumentNullException: {0}", e );
   }
   catch ( SocketException^ e ) 
   {
      Console::WriteLine( "SocketException: {0}", e );
   }
   finally
   {
      if (client != nullptr)
         delete client;
   }

   Console::WriteLine( "\n Press Enter to continue..." );
   Console::Read();
}

static void Connect(String server, String message)
{
  try
  {
    // Create a TcpClient.
    // Note, for this client to work you need to have a TcpServer
    // connected to the same address as specified by the server, port
    // combination.
    Int32 port = 13000;

    // Prefer a using declaration to ensure the instance is Disposed later.
    using TcpClient client = new TcpClient(server, port);

    // Translate the passed message into ASCII and store it as a Byte array.
    Byte[] data = System.Text.Encoding.ASCII.GetBytes(message);

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

    // Send the message to the connected TcpServer.
    stream.Write(data, 0, data.Length);

    Console.WriteLine("Sent: {0}", message);

    // Receive the server response.

    // Buffer to store the response bytes.
    data = new Byte[256];

    // String to store the response ASCII representation.
    String responseData = String.Empty;

    // Read the first batch of the TcpServer response bytes.
    Int32 bytes = stream.Read(data, 0, data.Length);
    responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
    Console.WriteLine("Received: {0}", responseData);

    // Explicit close is not necessary since TcpClient.Dispose() will be
    // called automatically.
    // stream.Close();
    // client.Close();
  }
  catch (ArgumentNullException e)
  {
    Console.WriteLine("ArgumentNullException: {0}", e);
  }
  catch (SocketException e)
  {
    Console.WriteLine("SocketException: {0}", e);
  }

  Console.WriteLine("\n Press Enter to continue...");
  Console.Read();
}

Shared Sub Connect(server As [String], message As [String])
   Try
      ' Create a TcpClient.
      ' Note, for this client to work you need to have a TcpServer 
      ' connected to the same address as specified by the server, port
      ' combination.
      Dim port As Int32 = 13000

      ' Prefer using declaration to ensure the instance is Disposed later.
      Using client As New TcpClient(server, port)
      
         ' Translate the passed message into ASCII and store it as a Byte array.
         Dim data As [Byte]() = System.Text.Encoding.ASCII.GetBytes(message)
         
         ' Get a client stream for reading and writing.
         Dim stream As NetworkStream = client.GetStream()
         
         ' Send the message to the connected TcpServer. 
         stream.Write(data, 0, data.Length)
         
         Console.WriteLine("Sent: {0}", message)
         
         ' Receive the server response.
         ' Buffer to store the response bytes.
         data = New [Byte](256) {}
         
         ' String to store the response ASCII representation.
         Dim responseData As [String] = [String].Empty
         
         ' Read the first batch of the TcpServer response bytes.
         Dim bytes As Int32 = stream.Read(data, 0, data.Length)
         responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes)
         Console.WriteLine("Received: {0}", responseData)
         
         ' Explicit close is not necessary since TcpClient.Dispose() will be
         ' called automatically.
         ' stream.Close()
         ' client.Close()
      End Using
   Catch e As ArgumentNullException
      Console.WriteLine("ArgumentNullException: {0}", e)
   Catch e As SocketException
      Console.WriteLine("SocketException: {0}", e)
   End Try
   
   Console.WriteLine(ControlChars.Cr + " Press Enter to continue...")
   Console.Read()
End Sub

Hinweise

Die TcpClient -Klasse bietet einfache Methoden zum Verbinden, Senden und Empfangen von Datenstromdaten über ein Netzwerk im synchronen Blockierungsmodus.

Um TcpClient eine Verbindung herzustellen und Daten auszutauschen, muss ein TcpListener oder Socket , das mit tcp ProtocolType erstellt wurde, auf eingehende Verbindungsanforderungen lauschen. Sie können eine Verbindung mit diesem Listener auf eine der folgenden zwei Arten herstellen:

• Create und TcpClient rufen Sie eine der drei verfügbaren Methoden aufConnect.

• Create mithilfe TcpClient des Hostnamens und der Portnummer des Remotehosts. Dieser Konstruktor versucht automatisch eine Verbindung.

Hinweis

Wenn Sie verbindungslose Datagramme im synchronen Blockierungsmodus senden möchten, verwenden Sie die UdpClient -Klasse.

Hinweise für Vererber

Verwenden Sie zum Senden und Empfangen von Daten die GetStream() -Methode, um eine NetworkStreamabzurufen. Rufen Sie die Write(Byte[], Int32, Int32) Methoden und Read(Byte[], Int32, Int32) von auf NetworkStream , um Daten mit dem Remotehost zu senden und zu empfangen. Verwenden Sie die Close(Int32) -Methode, um alle Ressourcen freizugeben, die dem TcpClientzugeordnet sind.

Konstruktoren

TcpClient()	Initialisiert eine neue Instanz der TcpClient-Klasse.
TcpClient(AddressFamily)	Initialisiert eine neue Instanz der TcpClient-Klasse mit der angegebenen Familie.
TcpClient(IPEndPoint)	Initialisiert eine neue Instanz der TcpClient-Klasse und bindet sie an den angegebenen lokalen Endpunkt.
TcpClient(String, Int32)	Initialisiert eine neue Instanz der TcpClient-Klasse und stellt eine Verbindung mit dem angegebenen Port am angegebenen Host her.

Eigenschaften

Active	Ruft einen Wert ab, der angibt, ob eine Verbindung hergestellt wurde, oder legt diesen fest.
Available	Ruft die Datenmenge ab, die über das Netzwerk empfangen wurde und gelesen werden kann.
Client	Ruft den zugrunde liegenden Socket ab oder legt diesen fest.
Connected	Ruft einen Wert ab, der angibt, ob der zugrunde liegende Socket für einen TcpClient mit einem Remotehost verbunden ist.
ExclusiveAddressUse	Ruft einen Boolean-Wert ab, der angibt, ob der TcpClient nur die Verwendung eines Port durch einen einzigen Client zulässt, oder legt diesen fest.
LingerState	Ruft Informationen zum Nachlaufzustand des zugeordneten Sockets ab oder legt sie fest.
NoDelay	Ruft einen Wert ab, der eine Verzögerung deaktiviert, wenn Sende- oder Empfangspuffer nicht voll sind, oder legt diesen fest.
ReceiveBufferSize	Ruft die Größe des Empfangspuffers ab oder legt diese fest.
ReceiveTimeout	Ruft den Zeitraum ab, den ein TcpClient nach dem Initiieren eines Lesevorgangs auf den Datenempfang wartet, oder legt diesen fest.
SendBufferSize	Ruft die Größe des Sendepuffers ab oder legt diese fest.
SendTimeout	Ruft die Zeitspanne ab, die ein TcpClient auf den erfolgreichen Abschluss eines Sendevorgangs wartet, oder legt diese fest.

Methoden

BeginConnect(IPAddress, Int32, AsyncCallback, Object)	Beginnt eine asynchrone Anforderung einer Remotehostverbindung. Der Remotehost wird durch eine IPAddress und eine Anschlussnummer (Int32) angegeben.
BeginConnect(IPAddress[], Int32, AsyncCallback, Object)	Beginnt eine asynchrone Anforderung einer Remotehostverbindung. Der Remotehost wird durch ein IPAddress-Array und eine Portnummer (Int32) angegeben.
BeginConnect(String, Int32, AsyncCallback, Object)	Beginnt eine asynchrone Anforderung einer Remotehostverbindung. Der Remotehost wird durch einen Hostnamen (String) und eine Anschlussnummer (Int32) angegeben.
Close()	Gibt diese TcpClient-Instanz frei und fordert an, dass die zugrundeliegende TCP-Verbindung geschlossen wird.
Connect(IPAddress, Int32)	Verbindet unter Verwendung der angegebenen IP-Adresse und Portnummer den Client mit einem TCP-Remotehost.
Connect(IPAddress[], Int32)	Verbindet unter Verwendung der angegebenen IP-Adressen und Portnummer den Client mit einem TCP-Remotehost.
Connect(IPEndPoint)	Verbindet unter Verwendung des angegebenen Endpunkts des Remotenetzwerks den Client mit einem TCP-Remotehost.
Connect(String, Int32)	Verbindet den Client mit dem angegebenen Port auf dem angegebenen Host.
ConnectAsync(IPAddress, Int32, CancellationToken)	Stellt mit der angegebenen IP-Adresse und der angegebenen Portnummer eine Verbindung zwischen dem Client und einem TCP-Remotehost als asynchronen Vorgang her.
ConnectAsync(IPAddress, Int32)	Stellt mit der angegebenen IP-Adresse und der angegebenen Portnummer eine Verbindung zwischen dem Client und einem TCP-Remotehost als asynchronen Vorgang her.
ConnectAsync(IPAddress[], Int32, CancellationToken)	Verbindet unter Verwendung der angegebenen IP-Adressen und Portnummer als asynchroner Vorgang den Client mit einem TCP-Remotehost.
ConnectAsync(IPAddress[], Int32)	Verbindet unter Verwendung der angegebenen IP-Adressen und Portnummer als asynchroner Vorgang den Client mit einem TCP-Remotehost.
ConnectAsync(IPEndPoint, CancellationToken)	Verbindet den Client mit einem TCP-Remotehost, indem der angegebene Endpunkt als asynchroner Vorgang verwendet wird.
ConnectAsync(IPEndPoint)	Verbindet den Client mit einem TCP-Remotehost, indem der angegebene Endpunkt als asynchroner Vorgang verwendet wird.
ConnectAsync(String, Int32, CancellationToken)	Verbindet den Client mit dem angegebenen TCP-Port auf dem angegebenen Host als asynchroner Vorgang.
ConnectAsync(String, Int32)	Verbindet den Client mit dem angegebenen TCP-Port auf dem angegebenen Host als asynchroner Vorgang.
Dispose()	Gibt die vom TcpClient verwendeten verwalteten und nicht verwalteten Ressourcen frei.
Dispose(Boolean)	Gibt die von TcpClient verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.
EndConnect(IAsyncResult)	Beendet einen ausstehenden asynchronen Verbindungsversuch.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
Finalize()	Gibt von der TcpClient-Klasse verwendete Ressourcen frei.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetStream()	Gibt den für das Senden und Empfangen von Daten verwendeten NetworkStream zurück.
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Weitere Informationen

• TcpListener
• NetworkStream
• Socket
• ProtocolType
• IPEndPoint
• Connect(String, Int32)
• Write(Byte[], Int32, Int32)
• Read(Byte[], Int32, Int32)
• TCP-UDP