sockets - studio - tcpclient c# example

Diferencia entre TCP Listener y Socket

Question

Por lo que sé, puedo crear un servidor utilizando tanto TCPListener como Socket, entonces, ¿cuál es la diferencia entre los dos?

Enchufe

private Socket MainSock;
MainSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
MainSock.Bind(new IPEndPoint(IPAddress.Any, port));
MainSock.Listen(500);
MainSock.BeginAccept(AcceptConnections, new Wrapper());

TCPListener

    Int32 port = 13000;
    IPAddress localAddr = IPAddress.Parse("127.0.0.1");
    TcpListener server = new TcpListener(localAddr, port);
    server.Start();

Estoy realmente confundido. Los dos escuchan las conexiones, entonces, ¿cuál es la diferencia entre ellos?

Código actualizado

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;
using System.Net.Security;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.IO;

public class Wrapper
{
    public byte[] buffer;
    public SslStream sslStream;
    public object connector;
}

public class Sock
{
    private Dictionary<string, byte> Connections;
    public event Action<Wrapper> AnnounceNewConnection;
    public event Action<Wrapper> AnnounceDisconnection;
    public event Action<byte[], Wrapper> AnnounceReceive;
    private Socket _sock;

    private X509Certificate certificate = X509Certificate.CreateFromCertFile("exportedcertificate.cer");

    public Sock(int port)
    {
        try
        {
            Connections = new Dictionary<string, byte>();
            _sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            _sock.Bind(new IPEndPoint(IPAddress.Any, port));
            _sock.Listen(500);
            _sock.BeginAccept(AcceptConnections, new Wrapper());
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
    }

    private void AcceptConnections(IAsyncResult result)
    {
        Wrapper wr = (Wrapper)result.AsyncState;
        try
        {
            wr.sslStream = new SslStream(new NetworkStream(_sock.EndAccept(result), true));
            wr.sslStream.BeginAuthenticateAsServer(certificate, AcceptAuthenticate, wr);

            _sock.BeginAccept(AcceptConnections, new Wrapper());
        }
        catch (Exception e) { Console.WriteLine(e); }
    }

    private void AcceptAuthenticate(IAsyncResult result)
    {
        Wrapper wr = (Wrapper)result.AsyncState;
        try
        {
            wr.sslStream.EndAuthenticateAsServer(result);
            if (wr.sslStream.IsAuthenticated == true)
            {
                AnnounceNewConnection.Invoke(wr);
            }
        }
        catch (Exception e) { Console.WriteLine(e); }
    }

    private void ReceiveData(IAsyncResult result)
    {
        Wrapper wr = (Wrapper)result.AsyncState;
        try
        {
            AnnounceReceive.Invoke(wr.buffer, wr);
        }
        catch (Exception e) { Console.WriteLine(e); AnnounceDisconnection.Invoke(wr); }
    }
}

Answer 1

Realmente no respondo la pregunta, pero parece que le gusta TcpClient mejor porque tiene GetStream() que puede usar con un SslStream , pero puede obtener un NetworkStream fuera de un Socket pasando el Socket como constructor de NetworkStream

es decir, NetworkStream myStream = new NetworkStream(mySocket);

Answer 2

Son simplemente diferentes clases que hacen lo mismo, escritas a diferentes niveles. Debajo del capó, el TCPListener sin duda llama algo muy parecido a su primer código basado en Socket. Está ahí para esconderte de algunos de los detalles sangrientos.

Answer 3

Un TcpListener envuelve un zócalo, y es el lado del servidor análogo al TcpClient (que también, por supuesto, envuelve un zócalo).

El TcpListener está preconfigurado con TCP (a diferencia del Socket, que se puede usar con UDP, IP puro, protocolos que no son IP, etc.) y le proporciona un TcpClient cuando maneja una conexión.

Si no está seguro de si necesita un Socket y está usando TCP, le recomiendo comenzar con TcpListener / Client, ya que es una interfaz mucho más fácil de usar.

Answer 4

TcpListener es un contenedor conveniente para las comunicaciones TCP. Esto le permite usar TcpClient para conexiones aceptadas, aunque puede aceptar sockets en lugar de clientes para usar Socket lugar de TcpClient . Puedes hacer lo mismo con Socket ; pero tiene que lidiar con algunos de los detalles de TCP (como SocketType.Stream, ProtocolType.Tcp ). TCP es un protocolo basado en TcpClient y TcpClient reconoce al permitirle transmitir comunicaciones al proporcionar una transmisión con TcpClient.GetStream() . Socket está en un nivel diferente más alto y necesita admitir muchos protocolos diferentes, como UDP, que no se basan en secuencias.

TcpClient.GetStream devuelve un objeto NetworkStream que es adecuado para SslStream ; entonces, debería ser mucho menos trabajo que usar Socket directamente. La documentación para los detalles de SslStream usando TcpListener y TcpClient para las comunicaciones SSL.