TcpListener Classe

Definição

Namespace:

System.Net.Sockets

Assembly:

System.Net.Sockets.dll

Origem:

TCPListener.cs

Escuta conexões de clientes de rede TCP.

public ref class TcpListener : IDisposable

public class TcpListener : IDisposable

type TcpListener = class
    interface IDisposable

Public Class TcpListener
Implements IDisposable

Herança

Object

TcpListener

Implementações

IDisposable

Exemplos

O exemplo de código a seguir cria um TcpListener.

#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Net;
using namespace System::Net::Sockets;
using namespace System::Text;
using namespace System::Threading;
void main()
{
   try
   {
      
      // Set the TcpListener on port 13000.
      Int32 port = 13000;
      IPAddress^ localAddr = IPAddress::Parse( "127.0.0.1" );
      
      // TcpListener* server = new TcpListener(port);
      TcpListener^ server = gcnew TcpListener( localAddr,port );
      
      // Start listening for client requests.
      server->Start();
      
      // Buffer for reading data
      array<Byte>^bytes = gcnew array<Byte>(256);
      String^ data = nullptr;
      
      // Enter the listening loop.
      while ( true )
      {
         Console::Write( "Waiting for a connection... " );
         
         // Perform a blocking call to accept requests.
         // You could also use server.AcceptSocket() here.
         TcpClient^ client = server->AcceptTcpClient();
         Console::WriteLine( "Connected!" );
         data = nullptr;
         
         // Get a stream Object* for reading and writing
         NetworkStream^ stream = client->GetStream();
         Int32 i;
         
         // Loop to receive all the data sent by the client.
         while ( i = stream->Read( bytes, 0, bytes->Length ) )
         {
            
            // Translate data bytes to a ASCII String*.
            data = Text::Encoding::ASCII->GetString( bytes, 0, i );
            Console::WriteLine( "Received: {0}", data );
            
            // Process the data sent by the client.
            data = data->ToUpper();
            array<Byte>^msg = Text::Encoding::ASCII->GetBytes( data );
            
            // Send back a response.
            stream->Write( msg, 0, msg->Length );
            Console::WriteLine( "Sent: {0}", data );
         }
         
         // Shutdown and end connection
         client->Close();
      }
   }
   catch ( SocketException^ e ) 
   {
      Console::WriteLine( "SocketException: {0}", e );
   }

   Console::WriteLine( "\nHit enter to continue..." );
   Console::Read();
}

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;

class MyTcpListener
{
  public static void Main()
  {
    TcpListener server = null;
    try
    {
      // Set the TcpListener on port 13000.
      Int32 port = 13000;
      IPAddress localAddr = IPAddress.Parse("127.0.0.1");

      // TcpListener server = new TcpListener(port);
      server = new TcpListener(localAddr, port);

      // Start listening for client requests.
      server.Start();

      // Buffer for reading data
      Byte[] bytes = new Byte[256];
      String data = null;

      // Enter the listening loop.
      while(true)
      {
        Console.Write("Waiting for a connection... ");

        // Perform a blocking call to accept requests.
        // You could also use server.AcceptSocket() here.
        using TcpClient client = server.AcceptTcpClient();
        Console.WriteLine("Connected!");

        data = null;

        // Get a stream object for reading and writing
        NetworkStream stream = client.GetStream();

        int i;

        // Loop to receive all the data sent by the client.
        while((i = stream.Read(bytes, 0, bytes.Length))!=0)
        {
          // Translate data bytes to a ASCII string.
          data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
          Console.WriteLine("Received: {0}", data);

          // Process the data sent by the client.
          data = data.ToUpper();

          byte[] msg = System.Text.Encoding.ASCII.GetBytes(data);

          // Send back a response.
          stream.Write(msg, 0, msg.Length);
          Console.WriteLine("Sent: {0}", data);
        }
      }
    }
    catch(SocketException e)
    {
      Console.WriteLine("SocketException: {0}", e);
    }
    finally
    {
      server.Stop();
    }

    Console.WriteLine("\nHit enter to continue...");
    Console.Read();
  }
}

Imports System.IO
Imports System.Net
Imports System.Net.Sockets
Imports System.Text

Class MyTcpListener

    Public Shared Sub Main()

    Dim server As TcpListener
    server=nothing
        Try
            ' Set the TcpListener on port 13000.
         Dim port As Int32 = 13000
         Dim localAddr As IPAddress = IPAddress.Parse("127.0.0.1")

         server = New TcpListener(localAddr, port)
         
         ' Start listening for client requests.
         server.Start()
         
         ' Buffer for reading data
            Dim bytes(1024) As Byte
            Dim data As String = Nothing
         
         ' Enter the listening loop.
         While True
            Console.Write("Waiting for a connection... ")
            
            ' Perform a blocking call to accept requests.
            ' You could also use server.AcceptSocket() here.
            Dim client As TcpClient = server.AcceptTcpClient()
            Console.WriteLine("Connected!")
            
            data = Nothing
            
            ' Get a stream object for reading and writing
            Dim stream As NetworkStream = client.GetStream()
            
            Dim i As Int32
            
            ' Loop to receive all the data sent by the client.
            i = stream.Read(bytes, 0, bytes.Length)
            While (i <> 0) 
               ' Translate data bytes to a ASCII string.
               data = System.Text.Encoding.ASCII.GetString(bytes, 0, i)
                    Console.WriteLine("Received: {0}", data)
               
               ' Process the data sent by the client.
               data = data.ToUpper()
                    Dim msg As Byte() = System.Text.Encoding.ASCII.GetBytes(data)
               
               ' Send back a response.
               stream.Write(msg, 0, msg.Length)
                    Console.WriteLine("Sent: {0}", data)
              
               i = stream.Read(bytes, 0, bytes.Length)

            End While
            
            ' Shutdown and end connection
            client.Close()
         End While
      Catch e As SocketException
         Console.WriteLine("SocketException: {0}", e)
      Finally
         server.Stop()
      End Try
      
      Console.WriteLine(ControlChars.Cr + "Hit enter to continue....")
      Console.Read()
   End Sub

End Class

Confira TcpClient um exemplo de cliente.

Comentários

A TcpListener classe fornece métodos simples que escutam e aceitam solicitações de conexão de entrada no modo síncrono de bloqueio. Você pode usar um TcpClient ou um Socket para se conectar a um TcpListener. Create um TcpListener usando um IPEndPoint, um endereço IP local e um número de porta ou apenas um número de porta. Especifique Any para o endereço IP local e 0 para o número da porta local se você quiser que o provedor de serviços subjacente atribua esses valores para você. Se você optar por fazer isso, poderá usar a LocalEndpoint propriedade para identificar as informações atribuídas, depois que o soquete tiver se conectado.

Use o Start método para começar a escutar solicitações de conexão de entrada. Start enfileirará conexões de entrada até que você chame o Stop método ou ele tenha enfileirado MaxConnections. Use ou AcceptSocketAcceptTcpClient para efetuar pull de uma conexão da fila de solicitação de conexão de entrada. Esses dois métodos serão bloqueados. Se você quiser evitar o bloqueio, use o Pending método primeiro para determinar se as solicitações de conexão estão disponíveis na fila.

Chame o Stop método para fechar o TcpListener.

Observação

O Stop método não fecha nenhuma conexão aceita. Você é responsável por fechá-los separadamente.

Construtores

TcpListener(Int32)	Obsoleto. Inicializa uma nova instância da classe TcpListener que escuta na porta especificada.
TcpListener(IPAddress, Int32)	Inicializa uma nova instância da classe TcpListener que escuta tentativas de conexões de entrada no endereço IP local e no número da porta especificados.
TcpListener(IPEndPoint)	Inicializa uma nova instância da classe TcpListener com o ponto de extremidade local especificado.

Propriedades

Active	Obtém um valor que indica se TcpListener está ouvindo ativamente as conexões de cliente.
ExclusiveAddressUse	Obtém ou define um valor Boolean que especifica se o TcpListener permite que apenas um soquete subjacente escute uma porta específica.
LocalEndpoint	Obtém o EndPoint subjacente do TcpListener atual.
Server	Obtém o Socket da rede subjacente.

Métodos

AcceptSocket()	Aceita uma solicitação de conexão pendente.
AcceptSocketAsync()	Aceita uma solicitação de conexão pendente como uma operação assíncrona.
AcceptSocketAsync(CancellationToken)	Aceita uma solicitação de conexão pendente como uma operação assíncrona cancelável.
AcceptTcpClient()	Aceita uma solicitação de conexão pendente.
AcceptTcpClientAsync()	Aceita uma solicitação de conexão pendente como uma operação assíncrona.
AcceptTcpClientAsync(CancellationToken)	Aceita uma solicitação de conexão pendente como uma operação assíncrona cancelável.
AllowNatTraversal(Boolean)	Habilita ou desabilita a passagem de NAT (Conversão de Endereços de Rede) em uma instância de TcpListener.
BeginAcceptSocket(AsyncCallback, Object)	Inicia uma operação assíncrona para aceitar uma tentativa de conexão de entrada.
BeginAcceptTcpClient(AsyncCallback, Object)	Inicia uma operação assíncrona para aceitar uma tentativa de conexão de entrada.
Create(Int32)	Cria uma nova instância TcpListener para escutar na porta especificada.
Dispose()	Libera todos os recursos usados pela instância de TcpListener atual.
EndAcceptSocket(IAsyncResult)	Aceita de forma assíncrona uma tentativa de conexão de entrada e cria um novo Socket para manipular as comunicações com o host remoto.
EndAcceptTcpClient(IAsyncResult)	Aceita de forma assíncrona uma tentativa de conexão de entrada e cria um novo TcpClient para manipular as comunicações com o host remoto.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
Pending()	Determina se há solicitações de conexão pendentes.
Start()	Começa a escutar as solicitações de conexão recebidas.
Start(Int32)	Começa a detectar solicitações de conexão recebidas com um número máximo conexões pendentes.
Stop()	Fecha o ouvinte.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Confira também

• TcpClient