TcpClient Clase

Definición

Espacio de nombres:

System.Net.Sockets

Ensamblado:

System.Net.Sockets.dll

Source:

TCPClient.cs

Proporciona conexiones de cliente para servicios de red TCP.

public ref class TcpClient : IDisposable

public class TcpClient : IDisposable

type TcpClient = class
    interface IDisposable

Public Class TcpClient
Implements IDisposable

Herencia

Object

TcpClient

Implementaciones

IDisposable

Ejemplos

El siguiente ejemplo de código establece una conexión TcpClient.

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

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.

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: Puede conectarse a este agente de escucha de una de las dos maneras siguientes:

• Crear un TcpClient y llamar a uno de los tres métodos Connect disponibles.

• Create mediante TcpClient el nombre de host y el número de puerto del host remoto. Este constructor intentará automáticamente una conexión.

Nota

Si desea enviar datagramas sin conexión en modo de bloqueo sincrónico, utilice la clase UdpClient.

Notas a los desarrolladores de herederos

Para enviar y recibir datos, use el método GetStream() para obtener un NetworkStream. Llame a los Write(Byte[], Int32, Int32) métodos y Read(Byte[], Int32, Int32) de NetworkStream para enviar y recibir datos con el host remoto. Use el método Close(Int32) para liberar todos los recursos asociados con el TcpClient.

Constructores

TcpClient()	Inicializa una nueva instancia de la clase TcpClient.
TcpClient(AddressFamily)	Inicializa una nueva instancia de la clase TcpClient con la familia especificada.
TcpClient(IPEndPoint)	Inicializa una nueva instancia de la clase TcpClient y la enlaza con el punto de conexión local especificado.
TcpClient(String, Int32)	Inicializa una nueva instancia de la clase TcpClient y se conecta al puerto especificado en el host especificado.

Propiedades

Active	Obtiene o establece un valor que indica si se ha establecido una conexión.
Available	Obtiene la cantidad de datos que se recibieron de la red y están disponibles para leer.
Client	Obtiene o establece el objeto Socket subyacente.
Connected	Obtiene un valor que indica si el objeto Socket subyacente de un objeto TcpClient está conectado a un host remoto.
ExclusiveAddressUse	Obtiene o establece un valor Boolean que especifica si el TcpClient permite a un único cliente usar un puerto.
LingerState	Obtiene o establece información sobre el estado de permanencia del socket asociado.
NoDelay	Obtiene o establece un valor que deshabilita cualquier retraso cuando los búferes de envío o recepción no están llenos.
ReceiveBufferSize	Obtiene o establece el tamaño del búfer de recepción.
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.
SendBufferSize	Obtiene o establece el tamaño del búfer de envío.
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.

Métodos

BeginConnect(IPAddress, Int32, AsyncCallback, Object)	Inicia una solicitud asincrónica para una conexión a host remoto. El host remoto se especifica mediante un IPAddress y un número de puerto (Int32).
BeginConnect(IPAddress[], Int32, AsyncCallback, Object)	Inicia una solicitud asincrónica para una conexión a host remoto. El host remoto se especifica mediante una matriz IPAddress y un número de puerto (Int32).
BeginConnect(String, Int32, AsyncCallback, Object)	Inicia una solicitud asincrónica para una conexión a host remoto. El host remoto se especifica mediante un nombre de host (String) y un número de puerto (Int32).
Close()	Elimina esta instancia TcpClient y solicita que se cierre la conexión TCP subyacente.
Connect(IPAddress, Int32)	Conecta el cliente a un host TCP remoto con la dirección IP y el número de puerto especificados.
Connect(IPAddress[], Int32)	Conecta el cliente a un host TCP remoto con las direcciones IP y el número de puerto que se especificaron.
Connect(IPEndPoint)	Conecta el cliente a un host TCP remoto con el punto de conexión de red remoto especificado.
Connect(String, Int32)	Conecta el cliente al puerto especificado en el host especificado.
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.
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.
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.
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.
ConnectAsync(IPEndPoint)	Conecta el cliente a un host TCP remoto mediante el punto de conexión especificado como una operación asincrónica.
ConnectAsync(IPEndPoint, CancellationToken)	Conecta el cliente a un host TCP remoto mediante el punto de conexión especificado como una operación asincrónica.
ConnectAsync(String, Int32)	Conecta al cliente con el puerto TCP especificado en el host especificado como una operación asincrónica.
ConnectAsync(String, Int32, CancellationToken)	Conecta al cliente con el puerto TCP especificado en el host especificado como una operación asincrónica.
Dispose()	Libera los recursos administrados y no administrados que utiliza el objeto TcpClient.
Dispose(Boolean)	Libera los recursos no administrados que usa TcpClient y, de forma opcional, libera los recursos administrados.
EndConnect(IAsyncResult)	Finaliza un intento de conexión asincrónica pendiente.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
Finalize()	Libera los recursos que usa la clase TcpClient.
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetStream()	Devuelve la NetworkStream usada para enviar y recibir datos.
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Consulte también

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