TcpClient Classe

Definição

Fornece conexões do cliente de serviços de rede TCP.Provides client connections for TCP network services.

public ref class TcpClient : IDisposable
public class TcpClient : IDisposable
type TcpClient = class
    interface IDisposable
Public Class TcpClient
Implements IDisposable
Herança
TcpClient
Implementações

Exemplos

O exemplo de código a seguir estabelece uma TcpClient conexão.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

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.The TcpClient class provides simple methods for connecting, sending, and receiving stream data over a network in synchronous blocking mode.

Para TcpClient conectar-se e trocar dados, um TcpListener ou Socket criado com o TCP ProtocolType deve estar escutando solicitações de conexão de entrada.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. Você pode se conectar a esse ouvinte de uma das duas maneiras a seguir:You can connect to this listener in one of the following two ways:

  • Crie um TcpClient e chame um dos três métodos disponíveis Connect .Create a TcpClient and call one of the three available Connect methods.

  • Crie um TcpClient usando o nome do host e o número da porta do host remoto.Create a TcpClient using the host name and port number of the remote host. Esse construtor tentará automaticamente uma conexão.This constructor will automatically attempt a connection.

Observação

Se você quiser enviar datagrams sem conexão no modo de bloqueio síncrono, use a UdpClient classe.If you want to send connectionless datagrams in synchronous blocking mode, use the UdpClient class.

Notas aos Herdeiros

Para enviar e receber dados, use o GetStream() método para obter um NetworkStream .To send and receive data, use the GetStream() method to obtain a NetworkStream. Chame os Write(Byte[], Int32, Int32) Read(Byte[], Int32, Int32) métodos e do NetworkStream para enviar e receber dados com o host remoto.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 o Close(Int32) método para liberar todos os recursos associados ao TcpClient .Use the Close(Int32) method to release all resources associated with the TcpClient.

Construtores

TcpClient()

Inicializa uma nova instância da classe TcpClient.Initializes a new instance of the TcpClient class.

TcpClient(AddressFamily)

Inicializa uma nova instância da classe TcpClient com a família especificada.Initializes a new instance of the TcpClient class with the specified family.

TcpClient(IPEndPoint)

Inicializa uma nova instância da classe TcpClient e a associa ao ponto de extremidade local especificado.Initializes a new instance of the TcpClient class and binds it to the specified local endpoint.

TcpClient(String, Int32)

Inicializa uma nova instância da classe TcpClient e se conecta à porta especificada no host especificado.Initializes a new instance of the TcpClient class and connects to the specified port on the specified host.

Propriedades

Active

Obtém ou define um valor que indica se uma conexão foi estabelecida.Gets or sets a value that indicates whether a connection has been made.

Available

Obtém a quantidade de dados recebidos da rede e disponíveis para leitura.Gets the amount of data that has been received from the network and is available to be read.

Client

Obtém ou define o Socket subjacente.Gets or sets the underlying Socket.

Connected

Obtém um valor que indica se o Socket subjacente de um TcpClient está conectado a um host remoto.Gets a value indicating whether the underlying Socket for a TcpClient is connected to a remote host.

ExclusiveAddressUse

Obtém ou define um valor Boolean que especifica se o TcpClient permite que um único cliente use uma porta.Gets or sets a Boolean value that specifies whether the TcpClient allows only one client to use a port.

LingerState

Obtém ou define as informações sobre o estado remanescente do soquete associado.Gets or sets information about the linger state of the associated socket.

NoDelay

Obtém ou define um valor que desabilita um atraso ao enviar ou receber buffers que não estão cheios.Gets or sets a value that disables a delay when send or receive buffers are not full.

ReceiveBufferSize

Obtém ou define o tamanho do buffer de recepção.Gets or sets the size of the receive buffer.

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.Gets or sets the amount of time a TcpClient will wait to receive data once a read operation is initiated.

SendBufferSize

Obtém ou define o tamanho do buffer de envio.Gets or sets the size of the send buffer.

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.Gets or sets the amount of time a TcpClient will wait for a send operation to complete successfully.

Métodos

BeginConnect(IPAddress, Int32, AsyncCallback, Object)

Inicia uma solicitação assíncrona para uma conexão de host remoto.Begins an asynchronous request for a remote host connection. O host remoto é especificado por um IPAddress e um número da porta (Int32).The remote host is specified by an IPAddress and a port number (Int32).

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

Inicia uma solicitação assíncrona para uma conexão de host remoto.Begins an asynchronous request for a remote host connection. O host remoto é especificado por uma matriz IPAddress e um número da porta (Int32).The remote host is specified by an IPAddress array and a port number (Int32).

BeginConnect(String, Int32, AsyncCallback, Object)

Inicia uma solicitação assíncrona para uma conexão de host remoto.Begins an asynchronous request for a remote host connection. O host remoto é especificado por um nome do host (String) e um número da porta (Int32).The remote host is specified by a host name (String) and a port number (Int32).

Close()

Descarta essa instância de TcpClient e solicita que a conexão TCP subjacente seja fechada.Disposes this TcpClient instance and requests that the underlying TCP connection be closed.

Connect(IPAddress, Int32)

Conecta o cliente a um host TCP remoto usando o número da porta e o endereço IP especificados.Connects the client to a remote TCP host using the specified IP address and port number.

Connect(IPAddress[], Int32)

Conecta o cliente a um host TCP remoto usando o número da porta e endereços IP especificados.Connects the client to a remote TCP host using the specified IP addresses and port number.

Connect(IPEndPoint)

Conecta o cliente a um host TCP remoto usando o ponto de extremidade de rede remoto especificado.Connects the client to a remote TCP host using the specified remote network endpoint.

Connect(String, Int32)

Conecta o cliente à porta especificada no host especificado.Connects the client to the specified port on the specified host.

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

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

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

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

ConnectAsync(String, Int32)

Conecta o cliente à porta TCP especificada no host especificado como uma operação assíncrona.Connects the client to the specified TCP port on the specified host as an asynchronous operation.

ConnectAsync(String, Int32, CancellationToken)

Conecta o cliente à porta TCP especificada no host especificado como uma operação assíncrona.Connects the client to the specified TCP port on the specified host as an asynchronous operation.

Dispose()

Libera os recursos gerenciados e não gerenciados usados pelo TcpClient.Releases the managed and unmanaged resources used by the TcpClient.

Dispose(Boolean)

Libera os recursos não gerenciados usados pelo TcpClient e opcionalmente libera os recursos gerenciados.Releases the unmanaged resources used by the TcpClient and optionally releases the managed resources.

EndConnect(IAsyncResult)

Encerra uma tentativa de conexão assíncrona pendente.Ends a pending asynchronous connection attempt.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
Finalize()

Libera os recursos usados pela classe TcpClient.Frees resources used by the TcpClient class.

GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetStream()

Retorna o NetworkStream usado para enviar e receber dados.Returns the NetworkStream used to send and receive data.

GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Herdado de Object)

Implantações explícitas de interface

IDisposable.Dispose()

Esta API dá suporte à infraestrutura do produto e não deve ser usada diretamente do seu código.

Libera todos os recursos usados pelo TcpClient.Releases all resources used by the TcpClient.

Aplica-se a

Confira também