TcpClient Třída

Reference

Definice

Obor názvů:: System.Net.Sockets

Sestavení:: System.Net.Sockets.dll

Sestavení:: System.dll

Sestavení:: netstandard.dll

Zdroj:: TCPClient.cs

Zdroj:: TCPClient.cs

Zdroj:: TCPClient.cs

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Poskytuje klientská připojení pro síťové služby TCP.

public ref class TcpClient : IDisposable

public class TcpClient : IDisposable

type TcpClient = class
    interface IDisposable

Public Class TcpClient
Implements IDisposable

Dědičnost: Object
TcpClient

Implementuje: IDisposable

Příklady

Následující příklad kódu naváže TcpClient připojení.

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

Poznámky

Třída TcpClient poskytuje jednoduché metody pro připojení, odesílání a příjem dat datového proudu přes síť v synchronním režimu blokování.

Aby bylo možné TcpClient se připojit a vyměňovat data, TcpListener musí objekt nebo Socket vytvořený pomocí protokolu TCP ProtocolType naslouchat příchozím požadavkům na připojení. K tomuto naslouchacímu procesu se můžete připojit jedním z následujících dvou způsobů:

TcpClient Create a zavolejte jednu ze tří dostupných Connect metod.
TcpClient Create pomocí názvu hostitele a čísla portu vzdáleného hostitele. Tento konstruktor se automaticky pokusí o připojení.

Poznámka

Pokud chcete odesílat datagramy bez připojení v synchronním režimu blokování, použijte UdpClient třídu .

Poznámky pro dědice

Pokud chcete odesílat a přijímat data, použijte metodu GetStream()NetworkStreamk získání . Write(Byte[], Int32, Int32) Voláním metod NetworkStream a Read(Byte[], Int32, Int32) pro odesílání a přijímání dat se vzdáleným hostitelem. Close(Int32) Pomocí metody uvolněte všechny prostředky přidružené k TcpClient.

Konstruktory

TcpClient()	Inicializuje novou instanci TcpClient třídy.
TcpClient(AddressFamily)	Inicializuje novou instanci TcpClient třídy se zadanou rodinou.
TcpClient(IPEndPoint)	Inicializuje novou instanci TcpClient třídy a vytvoří vazbu na zadaný místní koncový bod.
TcpClient(String, Int32)	Inicializuje novou instanci TcpClient třídy a připojí se k zadanému portu na zadaném hostiteli.

Vlastnosti

Active	Získá nebo nastaví hodnotu, která označuje, zda bylo připojení provedeno.
Available	Získá množství dat, které byly přijaty ze sítě a je k dispozici ke čtení.
Client	Získá nebo nastaví základní Socketobjekt .
Connected	Získá hodnotu označující, zda je podkladový Socket pro TcpClient je připojen ke vzdálenému hostiteli.
ExclusiveAddressUse	Získá nebo nastaví Boolean hodnotu, která určuje, zda TcpClient umožňuje pouze jeden klient používat port.
LingerState	Získá nebo nastaví informace o stavu linger přidruženého soketu.
NoDelay	Získá nebo nastaví hodnotu, která zakáže zpoždění při odesílání nebo příjmu vyrovnávací paměti nejsou plné.
ReceiveBufferSize	Získá nebo nastaví velikost vyrovnávací paměti pro příjem.
ReceiveTimeout	Získá nebo nastaví dobu, po TcpClient kterou bude čekat na přijetí dat po zahájení operace čtení.
SendBufferSize	Získá nebo nastaví velikost vyrovnávací paměti odesílání.
SendTimeout	Získá nebo nastaví dobu, po TcpClient kterou bude čekat na úspěšné dokončení operace odeslání.

Metody

BeginConnect(IPAddress, Int32, AsyncCallback, Object)	Zahájí asynchronní požadavek na připojení ke vzdálenému hostiteli. Vzdálený hostitel je určen číslem IPAddress portu a (Int32).
BeginConnect(IPAddress[], Int32, AsyncCallback, Object)	Zahájí asynchronní požadavek na připojení ke vzdálenému hostiteli. Vzdálený hostitel je určen polem IPAddress a číslem portu (Int32).
BeginConnect(String, Int32, AsyncCallback, Object)	Zahájí asynchronní požadavek na připojení ke vzdálenému hostiteli. Vzdálený hostitel je určen názvem hostitele (String) a číslem portu (Int32).
Close()	Odstraní tuto TcpClient instanci a požádá o ukončení základního připojení TCP.
Connect(IPAddress, Int32)	Připojí klienta ke vzdálenému hostiteli TCP pomocí zadané IP adresy a čísla portu.
Connect(IPAddress[], Int32)	Připojí klienta ke vzdálenému hostiteli TCP pomocí zadaných IP adres a čísla portu.
Connect(IPEndPoint)	Připojí klienta ke vzdálenému hostiteli TCP pomocí zadaného koncového bodu vzdálené sítě.
Connect(String, Int32)	Připojí klienta k zadanému portu na zadaném hostiteli.
ConnectAsync(IPAddress, Int32)	Připojí klienta ke vzdálenému hostiteli TCP pomocí zadané IP adresy a čísla portu jako asynchronní operace.
ConnectAsync(IPAddress, Int32, CancellationToken)	Připojí klienta ke vzdálenému hostiteli TCP pomocí zadané IP adresy a čísla portu jako asynchronní operace.
ConnectAsync(IPAddress[], Int32)	Připojí klienta ke vzdálenému hostiteli TCP pomocí zadaných IP adres a čísla portu jako asynchronní operace.
ConnectAsync(IPAddress[], Int32, CancellationToken)	Připojí klienta ke vzdálenému hostiteli TCP pomocí zadaných IP adres a čísla portu jako asynchronní operace.
ConnectAsync(IPEndPoint)	Připojí klienta ke vzdálenému hostiteli TCP pomocí zadaného koncového bodu jako asynchronní operace.
ConnectAsync(IPEndPoint, CancellationToken)	Připojí klienta ke vzdálenému hostiteli TCP pomocí zadaného koncového bodu jako asynchronní operace.
ConnectAsync(String, Int32)	Připojí klienta k zadanému portu TCP na zadaném hostiteli jako asynchronní operaci.
ConnectAsync(String, Int32, CancellationToken)	Připojí klienta k zadanému portu TCP na zadaném hostiteli jako asynchronní operaci.
Dispose()	Uvolní spravované a nespravované prostředky používané nástrojem TcpClient.
Dispose(Boolean)	Uvolní nespravované prostředky používané TcpClient nástrojem a volitelně uvolní spravované prostředky.
EndConnect(IAsyncResult)	Ukončí nevyřízený pokus o asynchronní připojení.
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
Finalize()	Uvolní prostředky používané TcpClient třídou.
GetHashCode()	Slouží jako výchozí hashovací funkce. (Zděděno od Object)
GetStream()	Vrátí hodnotu použitou NetworkStream k odesílání a přijímání dat.
GetType()	Získá aktuální Type instanci. (Zděděno od Object)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)

Explicitní implementace rozhraní

IDisposable.Dispose()

Toto rozhraní API podporuje produktovou infrastrukturu a není určené k použití přímo z uživatelského kódu.

Uvolní všechny prostředky používané nástrojem TcpClient.

Platí pro