TcpListener Clase

Definición

Espacio de nombres:

System.Net.Sockets

Ensamblado:

System.Net.Sockets.dll

Source:

TCPListener.cs

Realiza escuchas para conexiones de clientes de red TCP.

public ref class TcpListener : IDisposable

public class TcpListener : IDisposable

type TcpListener = class
    interface IDisposable

Public Class TcpListener
Implements IDisposable

Herencia

Object

TcpListener

Implementaciones

IDisposable

Ejemplos

En el ejemplo de código siguiente se crea un TcpListenerobjeto .

#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

Consulte TcpClient para obtener un ejemplo de cliente.

Comentarios

La TcpListener clase proporciona métodos sencillos que escuchan y aceptan solicitudes de conexión entrantes en el modo sincrónico de bloqueo. Puede usar o TcpClient para Socket conectarse con .TcpListener Create mediante TcpListener , IPEndPointuna dirección IP local y un número de puerto, o simplemente un número de puerto. Especifique Any para la dirección IP local y 0 para el número de puerto local si desea que el proveedor de servicios subyacente asigne esos valores. Si decide hacerlo, puede usar la propiedad para identificar la LocalEndpoint información asignada, después de que el socket se haya conectado.

Use el Start método para empezar a escuchar las solicitudes de conexión entrantes. Start pondrá en cola las conexiones entrantes hasta que llame al Stop método o haya puesto en MaxConnectionscola . Use o AcceptSocketAcceptTcpClient para extraer una conexión de la cola de solicitudes de conexión entrantes. Estos dos métodos se bloquearán. Si desea evitar el bloqueo, puede usar el Pending método primero para determinar si las solicitudes de conexión están disponibles en la cola.

Llame al Stop método para cerrar .TcpListener

Nota

El Stop método no cierra ninguna conexión aceptada. Usted es responsable de cerrarlos por separado.

Constructores

TcpListener(Int32)	Obsoletos. Inicializa una nueva instancia de la clase TcpListener que escucha en el puerto especificado.
TcpListener(IPAddress, Int32)	Inicializa una nueva instancia de la clase TcpListener que escucha los intentos de conexión entrantes en la dirección IP local y el número de puerto especificados.
TcpListener(IPEndPoint)	Inicializa una nueva instancia de la clase TcpListener con el extremo local especificado.

Propiedades

Active	Obtiene un valor que indica si TcpListener escucha activamente las conexiones de clientes.
ExclusiveAddressUse	Obtiene o establece un valor Boolean que especifica si TcpListener permite a sólo un socket subyacente escuchar en un puerto concreto.
LocalEndpoint	Obtiene el objeto EndPoint subyacente del objeto TcpListener actual.
Server	Obtiene el objeto de red Socket subyacente.

Métodos

AcceptSocket()	Acepta una solicitud de conexión pendiente.
AcceptSocketAsync()	Acepta una solicitud de conexión pendiente como una operación asincrónica.
AcceptSocketAsync(CancellationToken)	Acepta una solicitud de conexión pendiente como una operación asincrónica cancelable.
AcceptTcpClient()	Acepta una solicitud de conexión pendiente.
AcceptTcpClientAsync()	Acepta una solicitud de conexión pendiente como una operación asincrónica.
AcceptTcpClientAsync(CancellationToken)	Acepta una solicitud de conexión pendiente como una operación asincrónica cancelable.
AllowNatTraversal(Boolean)	Habilita o deshabilita NAT (Traducción de direcciones de red) transversal en una instancia de TcpListener.
BeginAcceptSocket(AsyncCallback, Object)	Comienza una operación asincrónica para aceptar un intento de conexión entrante.
BeginAcceptTcpClient(AsyncCallback, Object)	Comienza una operación asincrónica para aceptar un intento de conexión entrante.
Create(Int32)	Crea una nueva instancia de TcpListener para realizar escuchas en el puerto especificado.
Dispose()	Libera todos los recursos utilizados por la instancia TcpListener actual.
EndAcceptSocket(IAsyncResult)	Acepta asincrónicamente un intento de conexión entrante y crea un nuevo objeto Socket para controlar la comunicación con el host remoto.
EndAcceptTcpClient(IAsyncResult)	Acepta asincrónicamente un intento de conexión entrante y crea un nuevo objeto TcpClient para controlar la comunicación con el host remoto.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
Pending()	Determina si existen solicitudes de conexión pendientes.
Start()	Comienza la escucha de solicitudes de conexión entrantes.
Start(Int32)	Comienza la escucha de solicitudes de conexión entrantes en un número máximo de conexión pendiente.
Stop()	Cierra el agente de escucha.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Consulte también

• TcpClient