TcpClient Classe

Référence

Définition

Espace de noms:: System.Net.Sockets

Assembly:: System.Net.Sockets.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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 )
{
   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

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 TcpClient pouvoir se connecter et échanger des données, une TcpListener ou Socket une création 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 :

Créez un TcpClient et appelez l’une des trois méthodes disponibles Connect .
Créez un TcpClient nom d’hôte et le 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 méthodes et Read(Byte[], Int32, Int32) les Write(Byte[], Int32, Int32) méthodes d’envoi NetworkStream et de réception de données avec l’hôte distant. Utilisez la Close(Int32) méthode pour libérer toutes les ressources associées au 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)	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 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 les adresses 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(IPEndPoint)	Connecte le client à un hôte TCP distant à l’aide du point de terminaison spécifié en tant qu’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(String, Int32)	Connecte le client au port TCP spécifié sur l'hôte spécifié sous forme d'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.
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)

Implémentations d’interfaces explicites

IDisposable.Dispose()

Cette API prend en charge l'infrastructure du produit et n'est pas destinée à être utilisée directement à partir de votre code.

Libère toutes les ressources utilisées par TcpClient.

S’applique à