TcpClient Classe

Définition

Espace de noms:

System.Net.Sockets

Assembly:

System.Net.Sockets.dll

Source:

TCPClient.cs

Fournit des connexions clientes pour les services réseau TCP.

public ref class TcpClient : IDisposable

public class TcpClient : IDisposable

type TcpClient = class
    interface IDisposable

Public Class TcpClient
Implements IDisposable

Héritage

Object

TcpClient

Implémente

IDisposable

Exemples

L’exemple de code suivant établit une TcpClient connexion.

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

Remarques

La TcpClient classe fournit des méthodes simples pour connecter, envoyer et recevoir des données de flux sur un réseau en mode de blocage synchrone.

Pour pouvoir TcpClient se connecter et échanger des données, un TcpListener ou Socket créé avec le protocole TCP ProtocolType doit être à l’écoute des demandes de connexion entrantes. Vous pouvez vous connecter à cet écouteur de l’une des deux manières suivantes :

• Create un TcpClient et appelez l’une des trois méthodes disponiblesConnect.

• Create à TcpClient l’aide du nom d’hôte et du numéro de port de l’hôte distant. Ce constructeur tente automatiquement une connexion.

Notes

Si vous souhaitez envoyer des datagrammes sans connexion en mode de blocage synchrone, utilisez la UdpClient classe .

Notes pour les héritiers

Pour envoyer et recevoir des données, utilisez la GetStream() méthode pour obtenir un NetworkStream. Appelez les Write(Byte[], Int32, Int32) méthodes et Read(Byte[], Int32, Int32) de pour NetworkStream envoyer et recevoir des données avec l’hôte distant. Utilisez la Close(Int32) méthode pour libérer toutes les ressources associées à .TcpClient

Constructeurs

TcpClient()	Initialise une nouvelle instance de la classe TcpClient.
TcpClient(AddressFamily)	Initialise une nouvelle instance de la classe TcpClient avec la famille spécifiée.
TcpClient(IPEndPoint)	Initialise une nouvelle instance de la classe TcpClient et la lie au point de terminaison local spécifié.
TcpClient(String, Int32)	Initialise une nouvelle instance de la classe TcpClient et établit une connexion au port spécifié sur l'hôte spécifié.

Propriétés

Active	Obtient ou définit une valeur indiquant si une connexion a été établie.
Available	Obtient la quantité de données reçues du réseau et disponibles pour la lecture.
Client	Obtient ou définit l'élément Socket sous-jacent.
Connected	Obtient une valeur indiquant si le Socket sous-jacent de TcpClient est connecté à un hôte distant.
ExclusiveAddressUse	Obtient ou définit une valeur Boolean qui spécifie si l'élément TcpClient n'autorise qu'un seul client à utiliser un port.
LingerState	Obtient ou définit les informations relatives à l'état de maintien du socket associé.
NoDelay	Obtient ou définit une valeur qui désactive un délai de temporisation quand les mémoires tampons d'envoi ou de réception ne sont pas saturées.
ReceiveBufferSize	Obtient ou définit la taille de la mémoire tampon de réception.
ReceiveTimeout	Obtient ou définit la durée pendant laquelle TcpClient attendra de recevoir des données une fois l'opération de lecture initialisée.
SendBufferSize	Obtient ou définit la taille de la mémoire tampon d'envoi.
SendTimeout	Obtient ou définit la durée pendant laquelle un élément TcpClient attendra qu'une opération d'envoi se termine correctement.

Méthodes

BeginConnect(IPAddress, Int32, AsyncCallback, Object)	Démarre une demande asynchrone pour une connexion d'hôte distant. L'hôte distant est spécifié par un élément IPAddress et un numéro de port (Int32).
BeginConnect(IPAddress[], Int32, AsyncCallback, Object)	Démarre une demande asynchrone pour une connexion d'hôte distant. L'hôte distant est spécifié par un tableau IPAddress et un numéro de port (Int32).
BeginConnect(String, Int32, AsyncCallback, Object)	Démarre une demande asynchrone pour une connexion d'hôte distant. L'hôte distant est spécifié par un nom d'hôte (String) et un numéro de port (Int32).
Close()	Supprime cette instance de TcpClient et demande que la connexion TCP sous-jacente soit fermée.
Connect(IPAddress, Int32)	Connecte le client à un hôte TCP distant en utilisant l'adresse IP et le numéro de port spécifiés.
Connect(IPAddress[], Int32)	Connecte le client à un hôte TCP distant en utilisant les adresses IP et le numéro de port spécifiés.
Connect(IPEndPoint)	Connecte le client à un hôte TCP distant en utilisant le point de terminaison réseau distant spécifié.
Connect(String, Int32)	Connecte le client au port spécifié sur l'hôte spécifié.
ConnectAsync(IPAddress, Int32, CancellationToken)	Connecte le client à un hôte TCP distant en utilisant l'adresse IP et le numéro de port spécifiés sous forme d'opération asynchrone.
ConnectAsync(IPAddress, Int32)	Connecte le client à un hôte TCP distant en utilisant l'adresse IP et le numéro de port spécifiés sous forme d'opération asynchrone.
ConnectAsync(IPAddress[], Int32, CancellationToken)	Connecte le client à un hôte TCP distant en utilisant les adresses IP et le numéro de port spécifiés sous forme d'opération asynchrone.
ConnectAsync(IPAddress[], Int32)	Connecte le client à un hôte TCP distant en utilisant les adresses IP et le numéro de port spécifiés sous forme d'opération asynchrone.
ConnectAsync(IPEndPoint, CancellationToken)	Connecte le client à un hôte TCP distant à l’aide du point de terminaison spécifié en tant qu’opération asynchrone.
ConnectAsync(IPEndPoint)	Connecte le client à un hôte TCP distant à l’aide du point de terminaison spécifié en tant qu’opération asynchrone.
ConnectAsync(String, Int32, CancellationToken)	Connecte le client au port TCP spécifié sur l'hôte spécifié sous forme d'opération asynchrone.
ConnectAsync(String, Int32)	Connecte le client au port TCP spécifié sur l'hôte spécifié sous forme d'opération asynchrone.
Dispose()	Libère toutes les ressources managées et non managées utilisées par TcpClient.
Dispose(Boolean)	Libère les ressources non managées utilisées par TcpClient et libère éventuellement les ressources managées.
EndConnect(IAsyncResult)	Met fin à une tentative de connexion asynchrone en attente.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
Finalize()	Libère les ressources utilisées par la classe TcpClient.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetStream()	Retourne le NetworkStream utilisé pour l'envoi et la réception de données.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Voir aussi

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