TcpClient Clase

Definición

Proporciona conexiones de cliente para servicios de red 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
Herencia
TcpClient
Implementaciones

Ejemplos

El siguiente ejemplo de código establece una conexión TcpClient.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

Comentarios

La clase TcpClient proporciona métodos sencillos para conectarse, enviar, y recibir transmitir datos a través de una red en modo de bloqueo sincrónico. The TcpClient class provides simple methods for connecting, sending, and receiving stream data over a network in synchronous blocking mode.

Para que TcpClient pueda conectarse e intercambiar datos, un TcpListener o Socket creado con el ProtocolType TCP debe estar escuchando solicitudes de conexión entrantes. Puede conectarse a este agente de escucha en una de las dos maneras siguientes: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. Puede conectarse a este agente de escucha de una de las dos maneras siguientes:You can connect to this listener in one of the following two ways:

  • Crear un TcpClient y llamar a uno de los tres métodos Connect disponibles.Create a TcpClient and call one of the three available Connect methods.

  • Cree un TcpClient mediante el nombre de host y el número de puerto del host remoto.Create a TcpClient using the host name and port number of the remote host. Este constructor intentará automáticamente una conexión.This constructor will automatically attempt a connection.

Nota

Si desea enviar datagramas sin conexión en modo de bloqueo sincrónico, utilice la clase UdpClient.If you want to send connectionless datagrams in synchronous blocking mode, use the UdpClient class.

Notas a los desarrolladores de herederos

Para enviar y recibir datos, use el método GetStream() para obtener un NetworkStream.To send and receive data, use the GetStream() method to obtain a NetworkStream. Llame a Write(Byte[], Int32, Int32) los Read(Byte[], Int32, Int32) métodos y de NetworkStream para enviar y recibir datos con el 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 el método Close(Int32) para liberar todos los recursos asociados con el TcpClient.Use the Close(Int32) method to release all resources associated with the TcpClient.

Constructores

TcpClient()

Inicializa una nueva instancia de la clase TcpClient.Initializes a new instance of the TcpClient class.

TcpClient(AddressFamily)

Inicializa una nueva instancia de la clase TcpClient con la familia especificada.Initializes a new instance of the TcpClient class with the specified family.

TcpClient(IPEndPoint)

Inicializa una nueva instancia de la clase TcpClient y la enlaza con el punto de conexión local especificado.Initializes a new instance of the TcpClient class and binds it to the specified local endpoint.

TcpClient(String, Int32)

Inicializa una nueva instancia de la clase TcpClient y se conecta al puerto especificado en el host especificado.Initializes a new instance of the TcpClient class and connects to the specified port on the specified host.

Propiedades

Active

Obtiene o establece un valor que indica si se ha establecido una conexión.Gets or sets a value that indicates whether a connection has been made.

Available

Obtiene la cantidad de datos que se recibieron de la red y están disponibles para leer.Gets the amount of data that has been received from the network and is available to be read.

Client

Obtiene o establece el objeto Socket subyacente.Gets or sets the underlying Socket.

Connected

Obtiene un valor que indica si el objeto Socket subyacente de un objeto TcpClient está conectado a un host remoto.Gets a value indicating whether the underlying Socket for a TcpClient is connected to a remote host.

ExclusiveAddressUse

Obtiene o establece un valor Boolean que especifica si el TcpClient permite a un único cliente usar un puerto.Gets or sets a Boolean value that specifies whether the TcpClient allows only one client to use a port.

LingerState

Obtiene o establece información sobre el estado de permanencia del socket asociado.Gets or sets information about the linger state of the associated socket.

NoDelay

Obtiene o establece un valor que deshabilita cualquier retraso cuando los búferes de envío o recepción no están llenos.Gets or sets a value that disables a delay when send or receive buffers are not full.

ReceiveBufferSize

Obtiene o establece el tamaño del búfer de recepción.Gets or sets the size of the receive buffer.

ReceiveTimeout

Obtiene o establece el período de tiempo durante el cual un TcpClient esperará para recibir datos tras iniciarse una operación de lectura.Gets or sets the amount of time a TcpClient will wait to receive data once a read operation is initiated.

SendBufferSize

Obtiene o establece el tamaño del búfer de envío.Gets or sets the size of the send buffer.

SendTimeout

Obtiene o establece el período de tiempo durante el cual un TcpClient esperará para que finalice correctamente una operación de envío.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 una solicitud asincrónica para una conexión a host remoto.Begins an asynchronous request for a remote host connection. El host remoto se especifica mediante un IPAddress y un número de puerto (Int32).The remote host is specified by an IPAddress and a port number (Int32).

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

Inicia una solicitud asincrónica para una conexión a host remoto.Begins an asynchronous request for a remote host connection. El host remoto se especifica mediante una matriz IPAddress y un número de puerto (Int32).The remote host is specified by an IPAddress array and a port number (Int32).

BeginConnect(String, Int32, AsyncCallback, Object)

Inicia una solicitud asincrónica para una conexión a host remoto.Begins an asynchronous request for a remote host connection. El host remoto se especifica mediante un nombre de host (String) y un número de puerto (Int32).The remote host is specified by a host name (String) and a port number (Int32).

Close()

Elimina esta instancia TcpClient y solicita que se cierre la conexión TCP subyacente.Disposes this TcpClient instance and requests that the underlying TCP connection be closed.

Connect(IPAddress, Int32)

Conecta el cliente a un host TCP remoto con la dirección IP y el número de puerto especificados.Connects the client to a remote TCP host using the specified IP address and port number.

Connect(IPAddress[], Int32)

Conecta el cliente a un host TCP remoto con las direcciones IP y el número de puerto que se especificaron.Connects the client to a remote TCP host using the specified IP addresses and port number.

Connect(IPEndPoint)

Conecta el cliente a un host TCP remoto con el punto de conexión de red remoto especificado.Connects the client to a remote TCP host using the specified remote network endpoint.

Connect(String, Int32)

Conecta el cliente al puerto especificado en el host especificado.Connects the client to the specified port on the specified host.

ConnectAsync(IPAddress, Int32)

Conecta el cliente a un host TCP remoto con la dirección IP y el número de puerto especificados como una operación asincrónica.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 el cliente a un host TCP remoto con la dirección IP y el número de puerto especificados como una operación asincrónica.Connects the client to a remote TCP host using the specified IP address and port number as an asynchronous operation.

ConnectAsync(IPAddress[], Int32)

Conecta el cliente a un host TCP remoto con las direcciones IP y el número de puerto especificados como una operación asincrónica.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 el cliente a un host TCP remoto con las direcciones IP y el número de puerto especificados como una operación asincrónica.Connects the client to a remote TCP host using the specified IP addresses and port number as an asynchronous operation.

ConnectAsync(String, Int32)

Conecta al cliente con el puerto TCP especificado en el host especificado como una operación asincrónica.Connects the client to the specified TCP port on the specified host as an asynchronous operation.

ConnectAsync(String, Int32, CancellationToken)

Conecta al cliente con el puerto TCP especificado en el host especificado como una operación asincrónica.Connects the client to the specified TCP port on the specified host as an asynchronous operation.

Dispose()

Libera los recursos administrados y no administrados que utiliza el objeto TcpClient.Releases the managed and unmanaged resources used by the TcpClient.

Dispose(Boolean)

Libera los recursos no administrados que usa TcpClient y, de forma opcional, libera los recursos administrados.Releases the unmanaged resources used by the TcpClient and optionally releases the managed resources.

EndConnect(IAsyncResult)

Finaliza un intento de conexión asincrónica pendiente.Ends a pending asynchronous connection attempt.

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
Finalize()

Libera los recursos que usa la clase TcpClient.Frees resources used by the TcpClient class.

GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetStream()

Devuelve la NetworkStream usada para enviar y recibir datos.Returns the NetworkStream used to send and receive data.

GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Heredado de Object)

Implementaciones de interfaz explícitas

IDisposable.Dispose()

Esta API admite la infraestructura de producto y no está pensada para usarse directamente en el código.

Libera todos los recursos que usa TcpClient.Releases all resources used by the TcpClient.

Se aplica a

Consulte también