Tcp | Template de código | C#

• Tcp | Template de código | C#

using System;
using System.Net.Sockets;
using System.Net;
using System.IO;
using System.Threading;

namespace port_listen
{
  class MainClass
  {
    public static void Main(string[] args)
    {
      Console.WriteLine("Starting...");
      TcpListener server = new TcpListener(IPAddress.Parse("0.0.0.0"), 66);
      server.Start();
      Console.WriteLine("Started.");
      while (true)
      {
        ClientWorking cw = new ClientWorking(server.AcceptTcpClient());
        new Thread(new ThreadStart(cw.DoSomethingWithClient)).Start();
      }
      server.Stop();
    }
  }

  class ClientWorking
  {
    private Stream ClientStream;
    private TcpClient Client;

    public ClientWorking(TcpClient Client)
    {
      this.Client = Client;
      ClientStream = Client.GetStream();
    }

    public void DoSomethingWithClient()
    {
      StreamWriter sw = new StreamWriter(ClientStream);
      StreamReader sr = new StreamReader(sw.BaseStream);
      sw.WriteLine("Hi. This is x2 TCP/IP easy-to-use server");
      sw.Flush();
      string data;
      try
      {
        while ((data = sr.ReadLine()) != "exit")
        {
          sw.WriteLine(data);
          sw.Flush();
        }
      }
      finally
      {
        sw.Close();
      }
    }
  }
}

Socket vs TCP

Em C#, você pode usar sockets e TCP para várias situações que envolvem comunicação em rede. Vamos entender os contextos e diferenças para saber quando cada um é aplicável:

Sockets

Sockets são uma maneira de estabelecer uma conexão de baixo nível entre um cliente e um servidor. Eles permitem a comunicação de dados bidirecional e podem ser usados com diferentes protocolos de transporte, como TCP (Transmission Control Protocol) e UDP (User Datagram Protocol). Você usaria sockets em C# quando precisar de um controle mais fino sobre a conexão e os dados transmitidos, ou quando precisar utilizar características específicas que não são diretamente suportadas por abstrações de mais alto nível.

Cenários de uso comuns incluem:

1. Aplicações de tempo real: Como jogos online ou aplicativos que exigem comunicação instantânea e contínua entre cliente e servidor.
2. Comunicação personalizada: Quando você precisa implementar um protocolo específico que não é suportado por padrões de alto nível.
3. Redes peer-to-peer: Onde múltiplos clientes se conectam diretamente uns aos outros sem um servidor central.

TCP

TCP é um protocolo de transporte que fornece comunicações de rede confiáveis e orientadas à conexão. Em C#, você usaria TCP geralmente através de abstrações como TcpClient e TcpListener, que simplificam o uso de sockets diretamente e são adequados para muitos usos de redes que não requerem a complexidade de gerenciar sockets brutos.

Cenários de uso comuns incluem:

1. Servidores web e clientes: Para enviar e receber solicitações HTTP, embora normalmente se usem abstrações ainda mais altas como frameworks de web.
2. Transferência de arquivos: Como a garantia de que todos os dados chegam na ordem correta e sem corrupção é essencial.
3. Aplicações de comunicação: Como chat de texto, onde é importante a garantia de que as mensagens sejam entregues integralmente e em sequência.

Conclusão

A escolha entre usar sockets diretamente ou abstrações baseadas em TCP em C# depende das necessidades específicas da sua aplicação. Se precisar de controle detalhado sobre os dados e a conexão, ou se estiver implementando funcionalidades que exigem manipulação específica de protocolos ou configurações de rede, os sockets podem ser mais apropriados. Para a maioria das outras situações onde a confiabilidade e a sequência são importantes, mas a complexidade pode ser minimizada, usar abstrações TCP como TcpClient e TcpListener é geralmente suficiente e mais conveniente.