TcpClient Classe

Definição

Namespace:

System.Net.Sockets

Assembly:

System.Net.Sockets.dll

Origem:

TCPClient.cs

Fornece conexões do cliente de serviços de rede TCP.

public ref class TcpClient : IDisposable

public class TcpClient : IDisposable

type TcpClient = class
    interface IDisposable

Public Class TcpClient
Implements IDisposable

Herança

Object

TcpClient

Implementações

IDisposable

Exemplos

O exemplo de código a seguir estabelece uma TcpClient conexão.

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

Comentários

A TcpClient classe fornece métodos simples para conectar, enviar e receber dados de fluxo em uma rede no modo de bloqueio síncrono.

Para TcpClient se conectar e trocar dados, um TcpListener ou Socket criado com o TCP ProtocolType deve estar escutando solicitações de conexão de entrada. Você pode se conectar a esse ouvinte de uma das duas maneiras a seguir:

• Crie um TcpClient e chame um dos três métodos disponíveis Connect .

• Crie um TcpClient usando o nome do host e o número da porta do host remoto. Esse construtor tentará automaticamente uma conexão.

Observação

Se você quiser enviar datagramas sem conexão no modo de bloqueio síncrono, use a UdpClient classe .

Notas aos Herdeiros

Para enviar e receber dados, use o GetStream() método para obter um NetworkStream. Chame os Write(Byte[], Int32, Int32) métodos e Read(Byte[], Int32, Int32) do NetworkStream para enviar e receber dados com o host remoto. Use o Close(Int32) método para liberar todos os recursos associados ao TcpClient.

Construtores

TcpClient()	Inicializa uma nova instância da classe TcpClient.
TcpClient(AddressFamily)	Inicializa uma nova instância da classe TcpClient com a família especificada.
TcpClient(IPEndPoint)	Inicializa uma nova instância da classe TcpClient e a associa ao ponto de extremidade local especificado.
TcpClient(String, Int32)	Inicializa uma nova instância da classe TcpClient e se conecta à porta especificada no host especificado.

Propriedades

Active	Obtém ou define um valor que indica se uma conexão foi estabelecida.
Available	Obtém a quantidade de dados recebidos da rede e disponíveis para leitura.
Client	Obtém ou define o Socket subjacente.
Connected	Obtém um valor que indica se o Socket subjacente de um TcpClient está conectado a um host remoto.
ExclusiveAddressUse	Obtém ou define um valor Boolean que especifica se o TcpClient permite que um único cliente use uma porta.
LingerState	Obtém ou define as informações sobre o estado remanescente do soquete associado.
NoDelay	Obtém ou define um valor que desabilita um atraso ao enviar ou receber buffers que não estão cheios.
ReceiveBufferSize	Obtém ou define o tamanho do buffer de recepção.
ReceiveTimeout	Obtém ou define a quantidade de tempo que um TcpClient aguardará para receber dados depois que uma operação de leitura for iniciada.
SendBufferSize	Obtém ou define o tamanho do buffer de envio.
SendTimeout	Obtém ou define a quantidade de tempo que um TcpClient aguardará para que uma operação de envio seja concluída com êxito.

Métodos

BeginConnect(IPAddress, Int32, AsyncCallback, Object)	Inicia uma solicitação assíncrona para uma conexão de host remoto. O host remoto é especificado por um IPAddress e um número da porta (Int32).
BeginConnect(IPAddress[], Int32, AsyncCallback, Object)	Inicia uma solicitação assíncrona para uma conexão de host remoto. O host remoto é especificado por uma matriz IPAddress e um número da porta (Int32).
BeginConnect(String, Int32, AsyncCallback, Object)	Inicia uma solicitação assíncrona para uma conexão de host remoto. O host remoto é especificado por um nome do host (String) e um número da porta (Int32).
Close()	Descarta essa instância de TcpClient e solicita que a conexão TCP subjacente seja fechada.
Connect(IPAddress, Int32)	Conecta o cliente a um host TCP remoto usando o número da porta e o endereço IP especificados.
Connect(IPAddress[], Int32)	Conecta o cliente a um host TCP remoto usando o número da porta e endereços IP especificados.
Connect(IPEndPoint)	Conecta o cliente a um host TCP remoto usando o ponto de extremidade de rede remoto especificado.
Connect(String, Int32)	Conecta o cliente à porta especificada no host especificado.
ConnectAsync(IPAddress, Int32)	Conecta o cliente a um host TCP remoto usando o número da porta e o endereço IP especificados como uma operação assíncrona.
ConnectAsync(IPAddress, Int32, CancellationToken)	Conecta o cliente a um host TCP remoto usando o número da porta e o endereço IP especificados como uma operação assíncrona.
ConnectAsync(IPAddress[], Int32)	Conecta o cliente a um host de TCP remoto usando o número da porta e os endereços IP especificados como uma operação assíncrona.
ConnectAsync(IPAddress[], Int32, CancellationToken)	Conecta o cliente a um host de TCP remoto usando o número da porta e os endereços IP especificados como uma operação assíncrona.
ConnectAsync(IPEndPoint)	Conecta o cliente a um host TCP remoto usando o ponto de extremidade especificado como uma operação assíncrona.
ConnectAsync(IPEndPoint, CancellationToken)	Conecta o cliente a um host TCP remoto usando o ponto de extremidade especificado como uma operação assíncrona.
ConnectAsync(String, Int32)	Conecta o cliente à porta TCP especificada no host especificado como uma operação assíncrona.
ConnectAsync(String, Int32, CancellationToken)	Conecta o cliente à porta TCP especificada no host especificado como uma operação assíncrona.
Dispose()	Libera os recursos gerenciados e não gerenciados usados pelo TcpClient.
Dispose(Boolean)	Libera os recursos não gerenciados usados pelo TcpClient e opcionalmente libera os recursos gerenciados.
EndConnect(IAsyncResult)	Encerra uma tentativa de conexão assíncrona pendente.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
Finalize()	Libera os recursos usados pela classe TcpClient.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetStream()	Retorna o NetworkStream usado para enviar e receber dados.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Confira também

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