TcpClient Třída

Definice

Poskytuje připojení klientů pro síťové služby 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
Dědičnost
TcpClient
Implementuje

Příklady

Následující příklad kódu vytvoří připojení 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

Poznámky

Třída TcpClient poskytuje jednoduché metody pro připojení, odesílání a příjem dat streamu přes síť v režimu synchronního blokování.The TcpClient class provides simple methods for connecting, sending, and receiving stream data over a network in synchronous blocking mode.

Aby bylo možné TcpClient připojit a vyměňovat data, musí TcpListener nebo Socket vytvořené pomocí ProtocolType TCP naslouchat příchozím žádostem o připojení.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. K tomuto naslouchacímu procesu se můžete připojit jedním z následujících dvou způsobů:You can connect to this listener in one of the following two ways:

  • Vytvořte TcpClient a zavolejte jednu ze tří dostupných metod Connect.Create a TcpClient and call one of the three available Connect methods.

  • Vytvořte TcpClient a použijte název hostitele a číslo portu vzdáleného hostitele.Create a TcpClient using the host name and port number of the remote host. Tento konstruktor se automaticky pokusí o připojení.This constructor will automatically attempt a connection.

Poznámka

Pokud chcete odesílat datagramy bez připojení v režimu synchronního blokování, použijte třídu UdpClient.If you want to send connectionless datagrams in synchronous blocking mode, use the UdpClient class.

Poznámky pro dědice

K odesílání a přijímání dat použijte metodu GetStream() k získání NetworkStream.To send and receive data, use the GetStream() method to obtain a NetworkStream. Chcete-li odesílat a přijímat data se vzdáleným hostitelem, zavolejte Write(Byte[], Int32, Int32) a Read(Byte[], Int32, Int32) metody NetworkStream.Call the Write(Byte[], Int32, Int32) and Read(Byte[], Int32, Int32) methods of the NetworkStream to send and receive data with the remote host. Použijte metodu Close(Int32) k uvolnění všech prostředků přidružených k TcpClient.Use the Close(Int32) method to release all resources associated with the TcpClient.

Konstruktory

TcpClient()

Inicializuje novou instanci třídy TcpClient třídy.Initializes a new instance of the TcpClient class.

TcpClient(AddressFamily)

Inicializuje novou instanci třídy TcpClient se zadanou rodinou.Initializes a new instance of the TcpClient class with the specified family.

TcpClient(IPEndPoint)

Inicializuje novou instanci třídy TcpClient a váže ji k určenému místnímu koncovému bodu.Initializes a new instance of the TcpClient class and binds it to the specified local endpoint.

TcpClient(String, Int32)

Inicializuje novou instanci třídy TcpClient a připojí se k zadanému portu zadaného hostitele.Initializes a new instance of the TcpClient class and connects to the specified port on the specified host.

Vlastnosti

Active

Získává nebo nastavuje hodnotu, která indikuje, jestli se vytvořilo připojení.Gets or sets a value that indicates whether a connection has been made.

Available

Načte množství dat, která byla přijata ze sítě a je k dispozici pro čtení.Gets the amount of data that has been received from the network and is available to be read.

Client

Získá nebo nastaví základní Socket.Gets or sets the underlying Socket.

Connected

Načte hodnotu, která označuje, jestli je základní Socket pro TcpClient připojená ke vzdálenému hostiteli.Gets a value indicating whether the underlying Socket for a TcpClient is connected to a remote host.

ExclusiveAddressUse

Získá nebo nastaví Booleanovou hodnotu, která určuje, jestli TcpClient umožňuje použít jenom jednoho klienta.Gets or sets a Boolean value that specifies whether the TcpClient allows only one client to use a port.

LingerState

Získá nebo nastaví informace o stavu permanentní přidruženého soketu.Gets or sets information about the linger state of the associated socket.

NoDelay

Získá nebo nastaví hodnotu, která zakazuje zpoždění při odeslání nebo přijetí vyrovnávací paměti.Gets or sets a value that disables a delay when send or receive buffers are not full.

ReceiveBufferSize

Získá nebo nastaví velikost vyrovnávací paměti pro příjem.Gets or sets the size of the receive buffer.

ReceiveTimeout

Získá nebo nastaví dobu, po kterou bude TcpClient po zahájení operace čtení čekat na přijetí dat.Gets or sets the amount of time a TcpClient will wait to receive data once a read operation is initiated.

SendBufferSize

Získá nebo nastaví velikost vyrovnávací paměti pro odesílání.Gets or sets the size of the send buffer.

SendTimeout

Získá nebo nastaví dobu, po kterou bude TcpClient čekat na úspěšné dokončení operace odeslání.Gets or sets the amount of time a TcpClient will wait for a send operation to complete successfully.

Metody

BeginConnect(IPAddress, Int32, AsyncCallback, Object)

Spustí asynchronní požadavek na připojení ke vzdálenému hostiteli.Begins an asynchronous request for a remote host connection. Vzdálený hostitel je určen IPAddress a číslem portu (Int32).The remote host is specified by an IPAddress and a port number (Int32).

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

Spustí asynchronní požadavek na připojení ke vzdálenému hostiteli.Begins an asynchronous request for a remote host connection. Vzdálený hostitel je určen IPAddressovým polem a číslem portu (Int32).The remote host is specified by an IPAddress array and a port number (Int32).

BeginConnect(String, Int32, AsyncCallback, Object)

Spustí asynchronní požadavek na připojení ke vzdálenému hostiteli.Begins an asynchronous request for a remote host connection. Vzdálený hostitel je určený názvem hostitele (String) a číslem portu (Int32).The remote host is specified by a host name (String) and a port number (Int32).

Close()

Odstraní tuto instanci TcpClient a požádá o ukončení základního připojení protokolu TCP.Disposes this TcpClient instance and requests that the underlying TCP connection be closed.

Connect(IPAddress, Int32)

Připojí klienta ke vzdálenému hostiteli TCP pomocí zadané IP adresy a čísla portu.Connects the client to a remote TCP host using the specified IP address and port number.

Connect(IPAddress[], Int32)

Připojí klienta ke vzdálenému hostiteli TCP pomocí zadaných IP adres a čísla portu.Connects the client to a remote TCP host using the specified IP addresses and port number.

Connect(IPEndPoint)

Připojí klienta ke vzdálenému hostiteli TCP pomocí zadaného koncového bodu vzdálené sítě.Connects the client to a remote TCP host using the specified remote network endpoint.

Connect(String, Int32)

Připojí klienta k zadanému portu na zadaném hostiteli.Connects the client to the specified port on the specified host.

ConnectAsync(IPAddress, Int32)

Připojí klienta ke vzdálenému hostiteli TCP pomocí zadané IP adresy a čísla portu jako asynchronní operace.Connects the client to a remote TCP host using the specified IP address and port number as an asynchronous operation.

ConnectAsync(IPAddress[], Int32)

Připojí klienta ke vzdálenému hostiteli TCP pomocí zadaných IP adres a čísla portu jako asynchronní operace.Connects the client to a remote TCP host using the specified IP addresses and port number as an asynchronous operation.

ConnectAsync(String, Int32)

Připojí klienta k zadanému portu TCP na zadaném hostiteli jako asynchronní operace.Connects the client to the specified TCP port on the specified host as an asynchronous operation.

Dispose()

Uvolňuje spravované a nespravované prostředky, které používá TcpClient.Releases the managed and unmanaged resources used by the TcpClient.

Dispose(Boolean)

Uvolní nespravované prostředky používané TcpClient a volitelně uvolňuje spravované prostředky.Releases the unmanaged resources used by the TcpClient and optionally releases the managed resources.

EndConnect(IAsyncResult)

Ukončí probíhající asynchronní pokus o připojení.Ends a pending asynchronous connection attempt.

Equals(Object)

Určuje, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
Finalize()

Uvolňuje prostředky používané TcpClient třídou.Frees resources used by the TcpClient class.

GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetStream()

Vrátí NetworkStream, která se používá k odesílání a příjmu dat.Returns the NetworkStream used to send and receive data.

GetType()

Získá Type aktuální instance.Gets the Type of the current instance.

(Zděděno od Object)
MemberwiseClone()

Vytvoří kopii aktuálního Objectbez podstruktury.Creates a shallow copy of the current Object.

(Zděděno od Object)
ToString()

Vrací řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Zděděno od Object)

Explicitní implementace rozhraní

IDisposable.Dispose()

Uvolní všechny prostředky, které TcpClientpoužívá.Releases all resources used by the TcpClient.

Zabezpečení

SocketPermission
Oprávnění k navázání odchozího připojení nebo přijetí příchozího požadavku.Permission to establish an outgoing connection or accept an incoming request.

Platí pro

Viz také