TcpClient Klasa

Definicja

Przestrzeń nazw:

System.Net.Sockets

Zestaw:

System.Net.Sockets.dll

Źródło:

TCPClient.cs

Zapewnia połączenia klienta 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

Object

TcpClient

Implementuje

IDisposable

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 nawiązać połączenie i wymienić dane, element TcpListener lub Socket utworzony za pomocą protokołu TCP ProtocolType musi nasłuchiwać przychodzących żądań połączenia. Połączenie z tym odbiornikiem można nawiązać na jeden z następujących dwóch sposobów:

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

• TcpClient Twórca przy użyciu nazwy hosta i numeru portu hosta zdalnego. Ten konstruktor automatycznie podejmie próbę 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 , aby uzyskać NetworkStreamelement . Wywołaj Write(Byte[], Int32, Int32) metody i Read(Byte[], Int32, Int32) , NetworkStream aby wysyłać i odbierać dane za pomocą hosta zdalnego. 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 odebranych 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 utrzymującym się 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 odbierania.
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 ukończenie operacji wysyłania.

Metody

BeginConnect(IPAddress, Int32, AsyncCallback, Object)	Rozpoczyna asynchroniczne żądanie połączenia hosta zdalnego. Host zdalny jest określony przez IPAddress numer 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 z 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, CancellationToken)	Łączy klienta z zdalnym hostem TCP przy użyciu określonego adresu IP i numeru portu jako operacji asynchronicznej.
ConnectAsync(IPAddress, Int32)	Łączy klienta z zdalnym hostem TCP przy użyciu określonego adresu IP i numeru portu jako operacji asynchronicznej.
ConnectAsync(IPAddress[], Int32, CancellationToken)	Łączy klienta z zdalnym hostem TCP przy użyciu określonych adresów IP i numeru portu jako operacji asynchronicznej.
ConnectAsync(IPAddress[], Int32)	Łączy klienta z zdalnym hostem TCP przy użyciu określonych adresów IP i numeru portu jako operacji asynchronicznej.
ConnectAsync(IPEndPoint, CancellationToken)	Łączy klienta z zdalnym hostem TCP przy użyciu określonego punktu końcowego jako operacji asynchronicznej.
ConnectAsync(IPEndPoint)	Łączy klienta z zdalnym hostem TCP przy użyciu określonego punktu końcowego jako operacji asynchronicznej.
ConnectAsync(String, Int32, CancellationToken)	Łączy klienta z określonym portem TCP na określonym hoście jako operacją asynchroniczną.
ConnectAsync(String, Int32)	Łą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 TcpClientprogram .
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 bieżące wystąpienie. (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)

Zobacz też

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