TcpClient Klasa

Definicja

Zapewnia połączenia klienckie dla usług sieciowych TCP.

public ref class TcpClient : IDisposable
public class TcpClient : IDisposable
type TcpClient = class
    interface IDisposable
Public Class TcpClient
Implements IDisposable
Dziedziczenie
TcpClient
Implementuje

Przykłady

Poniższy przykład kodu ustanawia TcpClient połączenie.

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

Uwagi

Klasa TcpClient udostępnia proste metody łączenia, wysyłania i odbierania danych strumienia za pośrednictwem sieci w trybie blokowania synchronicznego.

Aby TcpClient można było nawiązać połączenie i wymienić dane, element TcpListener lub Socket utworzony za pomocą protokołu TCP ProtocolType musi nasłuchiwać żądań połączeń przychodzących. Możesz nawiązać połączenie z tym odbiornikiem na jeden z następujących dwóch sposobów:

  • Utwórz metodę TcpClient i wywołaj jedną z trzech dostępnych Connect metod.

  • TcpClient Utwórz element przy użyciu nazwy hosta i numeru portu hosta zdalnego. Ten konstruktor automatycznie podejmie próbę nawiązania połączenia.

Uwaga

Jeśli chcesz wysłać bez połączenia datagramy w trybie blokowania synchronicznego, użyj UdpClient klasy .

Uwagi dotyczące dziedziczenia

Aby wysyłać i odbierać dane, użyj GetStream() metody w celu uzyskania NetworkStreamwartości . Wywołaj Write(Byte[], Int32, Int32) metody i Read(Byte[], Int32, Int32) elementu NetworkStream , aby wysyłać i odbierać dane z hostem zdalnym. Close(Int32) Użyj metody , aby zwolnić wszystkie zasoby skojarzone z programem TcpClient.

Konstruktory

TcpClient()

Inicjuje nowe wystąpienie klasy TcpClient.

TcpClient(AddressFamily)

Inicjuje TcpClient nowe wystąpienie klasy z określoną rodziną.

TcpClient(IPEndPoint)

Inicjuje TcpClient nowe wystąpienie klasy i wiąże je z określonym lokalnym punktem końcowym.

TcpClient(String, Int32)

Inicjuje TcpClient nowe wystąpienie klasy i łączy się z określonym portem na określonym hoście.

Właściwości

Active

Pobiera lub ustawia wartość wskazującą, czy nawiązano połączenie.

Available

Pobiera ilość danych, które zostały odebrane z sieci i jest dostępna do odczytu.

Client

Pobiera lub ustawia bazowy Socketelement .

Connected

Pobiera wartość wskazującą, czy element bazowy Socket dla elementu TcpClient jest połączony z hostem zdalnym.

ExclusiveAddressUse

Pobiera lub ustawia wartość określającą Boolean , czy TcpClient zezwala tylko jednemu klientowi na korzystanie z portu.

LingerState

Pobiera lub ustawia informacje o stanie pokuty skojarzonego gniazda.

NoDelay

Pobiera lub ustawia wartość, która wyłącza opóźnienie, gdy bufory wysyłania lub odbierania nie są pełne.

ReceiveBufferSize

Pobiera lub ustawia rozmiar buforu odbioru.

ReceiveTimeout

Pobiera lub ustawia czas TcpClient oczekiwania na odbieranie danych po zainicjowaniu operacji odczytu.

SendBufferSize

Pobiera lub ustawia rozmiar buforu wysyłania.

SendTimeout

Pobiera lub ustawia czas TcpClient oczekiwania na pomyślne zakończenie operacji wysyłania.

Metody

BeginConnect(IPAddress, Int32, AsyncCallback, Object)

Rozpoczyna asynchroniczne żądanie połączenia hosta zdalnego. Host zdalny jest określany za pomocą i IPAddress numeru portu (Int32).

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

Rozpoczyna asynchroniczne żądanie połączenia hosta zdalnego. Host zdalny jest określany przez tablicę IPAddress i numer portu (Int32).

BeginConnect(String, Int32, AsyncCallback, Object)

Rozpoczyna asynchroniczne żądanie połączenia hosta zdalnego. Host zdalny jest określany przez nazwę hosta (String) i numer portu (Int32).

Close()

Usuwa to TcpClient wystąpienie i żąda zamknięcia bazowego połączenia TCP.

Connect(IPAddress, Int32)

Łączy klienta ze zdalnym hostem TCP przy użyciu określonego adresu IP i numeru portu.

Connect(IPAddress[], Int32)

Łączy klienta ze zdalnym hostem TCP przy użyciu określonych adresów IP i numeru portu.

Connect(IPEndPoint)

Łączy klienta ze zdalnym hostem TCP przy użyciu określonego punktu końcowego sieci zdalnej.

Connect(String, Int32)

Łączy klienta z określonym portem na określonym hoście.

ConnectAsync(IPAddress, Int32)

Łączy klienta ze zdalnym hostem TCP przy użyciu określonego adresu IP i numeru portu jako operacji asynchronicznej.

ConnectAsync(IPAddress, Int32, CancellationToken)

Łączy klienta ze zdalnym hostem TCP przy użyciu określonego adresu IP i numeru portu jako operacji asynchronicznej.

ConnectAsync(IPAddress[], Int32)

Łączy klienta ze zdalnym hostem TCP przy użyciu określonych adresów IP i numeru portu jako operacji asynchronicznej.

ConnectAsync(IPAddress[], Int32, CancellationToken)

Łączy klienta ze zdalnym hostem TCP przy użyciu określonych adresów IP i numeru portu jako operacji asynchronicznej.

ConnectAsync(IPEndPoint)

Łączy klienta ze zdalnym hostem TCP przy użyciu określonego punktu końcowego jako operacji asynchronicznej.

ConnectAsync(IPEndPoint, CancellationToken)

Łączy klienta ze zdalnym hostem TCP przy użyciu określonego punktu końcowego jako operacji asynchronicznej.

ConnectAsync(String, Int32)

Łączy klienta z określonym portem TCP na określonym hoście jako operacją asynchroniczną.

ConnectAsync(String, Int32, CancellationToken)

Łączy klienta z określonym portem TCP na określonym hoście jako operacją asynchroniczną.

Dispose()

Zwalnia zarządzane i niezarządzane zasoby używane przez program TcpClient.

Dispose(Boolean)

Zwalnia zasoby niezarządzane używane przez element TcpClient i opcjonalnie zwalnia zasoby zarządzane.

EndConnect(IAsyncResult)

Kończy oczekującą próbę połączenia asynchronicznego.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
Finalize()

Zwalnia zasoby używane przez klasę TcpClient .

GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetStream()

Zwraca wartość używaną do wysyłania NetworkStream i odbierania danych.

GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)

Jawne implementacje interfejsu

IDisposable.Dispose()

Ten interfejs API obsługuje infrastrukturę produktu i nie jest przeznaczony do użycia bezpośrednio z poziomu kodu.

Zwalnia wszelkie zasoby używane przez element TcpClient.

Dotyczy

Zobacz też