TcpClient Class

Definition

Stellt Clientverbindungen für TCP-Netzwerkdienste bereit. Provides client connections for TCP network services.

public class TcpClient : IDisposable
Vererbung
TcpClient
Implementiert

Beispiele

Im folgenden Codebeispiel wird eine TcpClient Verbindung.The following code example establishes a TcpClient connection.

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;
      TcpClient^ 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.
      //  Stream stream = client->GetStream();

      NetworkStream^ stream = client->GetStream();
      
      // Send the message to the connected TcpServer. 
      stream->Write( data, 0, data->Length );

      Console::WriteLine( "Sent: {0}", message );
      
      // Receive the TcpServer::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 );
      
      // Close everything.
      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();
}
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;
    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.
   //  Stream stream = client.GetStream();
    
    NetworkStream stream = client.GetStream();

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

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

    // Receive the TcpServer.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);         

    // Close everything.
    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
      Dim 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.
      '  Stream stream = client.GetStream();
      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 TcpServer.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)
      
      ' Close everything.
      stream.Close()
      client.Close()
   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 'Connect

Hinweise

Die TcpClient Klasse bietet einfache Methoden zum Herstellen einer Verbindung, senden und empfangen Streamen von Daten über ein Netzwerk im synchronen, blockierenden Modus befindet.The TcpClient class provides simple methods for connecting, sending, and receiving stream data over a network in synchronous blocking mode.

In der Reihenfolge für TcpClient eine Verbindung herstellen und den Austausch von Daten, eine TcpListener oder Socket erstellt, mit dem TCP ProtocolType für eingehende verbindungsanforderungen überwacht werden müssen.In order for TcpClient to connect and exchange data, a TcpListener or Socket created with the TCP ProtocolType must be listening for incoming connection requests. Sie können in einem der beiden folgenden Methoden an diesen Listener verbinden:You can connect to this listener in one of the following two ways:

  • Erstellen Sie eine TcpClient und rufen Sie eine der drei verfügbaren Connect Methoden.Create a TcpClient and call one of the three available Connect methods.

  • Erstellen Sie eine TcpClient unter Verwendung des Hostnamens und die Portnummer des Remotehosts.Create a TcpClient using the host name and port number of the remote host. Dieser Konstruktor wird automatisch eine Verbindung herzustellen.This constructor will automatically attempt a connection.

Hinweis

Wenn Sie in den synchronen, blockierenden Modus verbindungslose Datagramme senden möchten, verwenden Sie die UdpClient Klasse.If you want to send connectionless datagrams in synchronous blocking mode, use the UdpClient class.

Hinweise für Vererber

Verwenden Sie zum Senden und Empfangen von Daten, die GetStream() Methode zum Abrufen einer NetworkStream. Rufen Sie die Write(Byte[], Int32, Int32) und Read(Byte[], Int32, Int32) Methoden der NetworkStream zum Senden und Empfangen von Daten mit dem Remotehost. Verwenden der Close(Int32) Methode, um alle zugeordneten Ressourcen freizugeben. die TcpClient.

To send and receive data, use the GetStream() method to obtain a NetworkStream. Call the Write(Byte[], Int32, Int32) and Read(Byte[], Int32, Int32) methods of the NetworkStream to send and receive data with the remote host. Use the Close(Int32) method to release all resources associated with the TcpClient.

Konstruktoren

TcpClient()

Initialisiert eine neue Instanz der TcpClient-Klasse. Initializes a new instance of the TcpClient class.

TcpClient(AddressFamily)

Initialisiert eine neue Instanz der TcpClient-Klasse mit der angegebenen Familie. Initializes a new instance of the TcpClient class with the specified family.

TcpClient(IPEndPoint)

Initialisiert eine neue Instanz der TcpClient-Klasse und bindet sie an den angegebenen lokalen Endpunkt. Initializes a new instance of the TcpClient class and binds it to the specified local endpoint.

TcpClient(String, Int32)

Initialisiert eine neue Instanz der TcpClient-Klasse und stellt eine Verbindung mit dem angegebenen Port am angegebenen Host her. Initializes a new instance of the TcpClient class and connects to the specified port on the specified host.

Eigenschaften

Active

Ruft einen Wert ab, der angibt, ob eine Verbindung hergestellt wurde, oder legt diesen fest. Gets or set a value that indicates whether a connection has been made.

Available

Ruft die Datenmenge ab, die über das Netzwerk empfangen wurde und gelesen werden kann. Gets the amount of data that has been received from the network and is available to be read.

Client

Ruft den zugrunde liegenden Socket ab oder legt diesen fest. Gets or sets the underlying Socket.

Connected

Ruft einen Wert ab, der angibt, ob der zugrundeliegende Socket für einen TcpClient mit einem Remotehost verbunden ist. Gets a value indicating whether the underlying Socket for a TcpClient is connected to a remote host.

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. Gets or sets a Boolean value that specifies whether the TcpClient allows only one client to use a port.

LingerState

Ruft Informationen zum Nachlaufzustand des zugeordneten Sockets ab oder legt sie fest. Gets or sets information about the linger state of the associated socket.

NoDelay

Ruft einen Wert ab, der eine Verzögerung deaktiviert, wenn Sende- oder Empfangspuffer nicht voll sind, oder legt diesen fest. Gets or sets a value that disables a delay when send or receive buffers are not full.

ReceiveBufferSize

Ruft die Größe des Empfangspuffers ab oder legt diese fest. Gets or sets the size of the receive buffer.

ReceiveTimeout

Ruft den Zeitraum ab, den ein TcpClient nach dem Beginn eines Lesevorgangs auf den Datenempfang wartet, oder legt diesen fest. Gets or sets the amount of time a TcpClient will wait to receive data once a read operation is initiated.

SendBufferSize

Ruft die Größe des Sendepuffers ab oder legt diese fest. Gets or sets the size of the send buffer.

SendTimeout

Ruft die Zeitspanne ab, die ein TcpClient auf den erfolgreichen Abschluss eines Sendevorgangs wartet, oder legt diese fest. Gets or sets the amount of time a TcpClient will wait for a send operation to complete successfully.

Methoden

BeginConnect(IPAddress, Int32, AsyncCallback, Object)

Beginnt eine asynchrone Anforderung einer Remotehostverbindung. Begins an asynchronous request for a remote host connection. Der Remotehost wird durch eine IPAddress und eine Portnummer (Int32) angegeben. The remote host is specified by an IPAddress and a port number (Int32).

BeginConnect(IPAddress[], Int32, AsyncCallback, Object)

Beginnt eine asynchrone Anforderung einer Remotehostverbindung. Begins an asynchronous request for a remote host connection. Der Remotehost wird durch ein IPAddress-Array und eine Portnummer (Int32) angegeben. The remote host is specified by an IPAddress array and a port number (Int32).

BeginConnect(String, Int32, AsyncCallback, Object)

Beginnt eine asynchrone Anforderung einer Remotehostverbindung. Begins an asynchronous request for a remote host connection. Der Remotehost wird durch einen Hostnamen (String) und eine Portnummer (Int32) angegeben. The remote host is specified by a host name (String) and a port number (Int32).

Close()

Gibt diese TcpClient-Instanz frei und fordert an, dass die zugrundeliegende TCP-Verbindung geschlossen wird. Disposes this TcpClient instance and requests that the underlying TCP connection be closed.

Connect(IPAddress, Int32)

Verbindet unter Verwendung der angegebenen IP-Adresse und Portnummer den Client mit einem TCP-Remotehost. Connects the client to a remote TCP host using the specified IP address and port number.

Connect(IPAddress[], Int32)

Verbindet unter Verwendung der angegebenen IP-Adressen und Portnummer den Client mit einem TCP-Remotehost. Connects the client to a remote TCP host using the specified IP addresses and port number.

Connect(IPEndPoint)

Verbindet unter Verwendung des angegebenen Endpunkts des Remotenetzwerks den Client mit einem TCP-Remotehost. Connects the client to a remote TCP host using the specified remote network endpoint.

Connect(String, Int32)

Verbindet den Client mit dem angegebenen Port auf dem angegebenen Host. Connects the client to the specified port on the specified host.

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. Connects the client to a remote TCP host using the specified IP address and port number as an asynchronous operation.

ConnectAsync(IPAddress[], Int32)

Verbindet unter Verwendung der angegebenen IP-Adressen und Portnummer als asynchroner Vorgang den Client mit einem TCP-Remotehost. Connects the client to a remote TCP host using the specified IP addresses and port number as an asynchronous operation.

ConnectAsync(String, Int32)

Verbindet den Client mit dem angegebenen TCP-Port auf dem angegebenen Host als asynchroner Vorgang. Connects the client to the specified TCP port on the specified host as an asynchronous operation.

Dispose()

Gibt die vom TcpClient verwendeten verwalteten und nicht verwalteten Ressourcen frei. Releases the managed and unmanaged resources used by the TcpClient.

Dispose(Boolean)

Gibt die von TcpClient verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. Releases the unmanaged resources used by the TcpClient and optionally releases the managed resources.

EndConnect(IAsyncResult)

Beendet einen ausstehenden asynchronen Verbindungsversuch. Ends a pending asynchronous connection attempt.

Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. Determines whether the specified object is equal to the current object.

(Inherited from Object)
Finalize()

Gibt von der TcpClient-Klasse verwendete Ressourcen frei. Frees resources used by the TcpClient class.

GetHashCode()

Fungiert als die Standardhashfunktion. Serves as the default hash function.

(Inherited from Object)
GetStream()

Gibt den für das Senden und Empfangen von Daten verwendeten NetworkStream zurück. Returns the NetworkStream used to send and receive data.

GetType()

Ruft den Type der aktuellen Instanz ab. Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object. Creates a shallow copy of the current Object.

(Inherited from Object)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. Returns a string that represents the current object.

(Inherited from Object)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Sicherheit

SocketPermission
Berechtigung für eine ausgehende Verbindung herzustellen, oder übernehmen Sie eine eingehende Anforderung. Permission to establish an outgoing connection or accept an incoming request.

Gilt für:

Siehe auch