O que é um Socket

Socket (soquete) é um mecanismo fundamental para comunicação em redes de computadores. Ele fornece uma interface de programação de aplicativos (API) que permite que aplicativos troquem dados através de redes.

No contexto da comunicação de rede, um Socket pode ser visto como uma abstração que facilita a conexão entre sistemas. Ele permite que aplicações em computadores distintos estabeleçam canais de comunicação bidirecionais. Por meio de Sockets, programas podem enviar e receber dados, realizando comunicação em tempo real e confiável entre si.

Os Sockets operam entre a camada de transporte e a camada de aplicação, responsáveis por lidar com os detalhes de baixo nível da rede. Eles encapsulam protocolos de rede subjacentes (como TCP ou UDP), oferecendo um conjunto de funções e métodos simples e eficazes, permitindo que desenvolvedores utilizem a rede de forma conveneinte para comunicação.

Modelo de Comunicação com Sockets

O processo geral de comunicação utilizando Sockets segue estas etapas:

1. Criação do Socket: A aplicação cria uma instância de Socket através de funções fornecidas pelo sistema ou bibliotecas, especificando protocolo de comunicação, endereço e porta.
2. Estabelecimento da conexão: Para o cliente, é iniciada uma solicitação de conexão direcionada ao endereço IP e porta do servidor; no lado do servidor, é realizada a escuta em uma porta específica, aceitando conexões quando solicitadas.
3. Transmissão de dados: Após a conexão estabelecida, a aplicação pode enviar e receber dados através do Socket. Ao enviar dados, eles são escritos no buffer de saída do Socket; ao receber, são lidos do buffer de entrada.
4. Encerramento da conexão: Ao final da comunicação, o Socket é fechado para liberar recursos.

Os Sockets oferecem diferentes protocolos de comunicação, sendo os mais comuns o TCP (Protocolo de Controle de Transmissão) e o UDP (Protocolo de Datagrama do Usuário). O TCP proporciona uma conexão confiável, garantindo transmissão ordenada dos dados; já o UDP opera sem conexão, oferecendo entrega de dados não confiável.

Em resumo, o Socket é uma interface de programação utilizada para implementar comunicação em redes de computadores. Ele fornece funções e métodos para criar conexões, enviar e receber dados, permitindo que aplicações realizem comunicação de rede de forma eficiente.

Buffers de Mensagem

O buffer de mensagem de Socket refere-se à área interna do objeto Socket utilizada para armazenar dados enviados e recebidos. Esses buffers permitem que aplicações realizem o armazenamento temporário e processamento de dados durante transmissão e recepção, melhorando eficiência e desempenho.

No envio de dados, a aplicação escreve as informações no buffer de saída do Socket. Esses dados não são transmitidos imediatamente para a rede, mas permanecem no buffer aguardando o momento adequado para envio. Por exemplo, quando o buffer está cheio ou a aplicativa aciona o método de envio, os dados são transmitidos.

Na recepção de dados, o Socket armazena as informações recebidas da rede no buffer de entrada, aguardando a aplicação para leitura. A aplicação pode obter as mensagens recebidas ao ler o buffer de entrada. Se o buffer estiver vazio, a aplicação pode ser bloqueada até que novos dados cheguem.

O tamanho do buffer de mensagem pode ser configurado conforme necessário. Buffers menores podem resultar em operações frequentes de envio e recepção, enquanto buffers maiores podem aumentar latência e consumo de memória. Portanto, em aplicações práticas, é necessário configurar adequadamente o tamanho do buffer com base na quantidade de dados transmitidos e nas necessidades de desempenho.

É importante notar que o buffer de mensagem atua apenas como armazenamento temporário de dados intermediários, enquanto a transmissão efetiva ainda ocorre através da rede. A API de Socket oferece métodos correspondentes para operar nos buffers de mensagem, como enviar dados, receber dados e limpar buffers.

Em síntese, o buffer de mensagem de Socket é uma área interna do objeto Socket utilizada para armazenar dados enviados e recebidos, desempenhando um papel crucial no armazenamento temporário e processamento durante a transmissão e recepção de dados.

Compreendendo "Sockets"

Em programação de computadores, sockets são interfaces de programação utilizadas para transmissão de dados em redes. Cada socket aberto recebe um identificador único pelo sistema operacional, conhecido como descritor de arquivo (fd). Esse identificador pode ser visto como uma referência ao socket aberto, através da qual operações como leitura, escrita e fechamento podem ser realizadas.

Demo Básica

Servidor

//1 Criar objeto Socket
servidorSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

//2 Associar IP e porta
IPAddress ip = IPAddress.Parse("127.0.0.1");
IPEndPoint pontoFinal = new IPEndPoint(ip, 50001);
servidorSocket.Bind(pontoFinal);

//3 Iniciar escuta (aguardando conexões de clientes), com limite de 10 clientes
servidorSocket.Listen(10);

//4 [Bloqueante], aguardando conexão do cliente
Socket novoSocket = servidorSocket.Accept();

//5 [Bloqueante], aguardando leitura de dados enviados pelo cliente
byte[] dados = new byte[1024 * 1024];
int tamanhoLido = novoSocket.Receive(dados, 0, dados.Length, SocketFlags.None);

//6 Processar dados
var mensagem = Encoding.UTF8.GetString(dados, 0, tamanhoLido);

Cliente

//1 Criar objeto Socket
clienteSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

//2 Conectar ao servidor
IPAddress ip = IPAddress.Parse("127.0.0.1");
IPEndPoint pontoFinal = new IPEndPoint(ip, 50001);
clienteSocket.Connect(pontoFinal);

//3 Enviar mensagem ao servidor
clienteSocket.Send(Encoding.UTF8.GetBytes("ola,mundo"));

Contudo, há um problema significativo: o servidor só pode estabelecer uma conexão com um cliente e receber uma mensagem dele. Para lidar com múltiplos clientes e mensagens indefinidamente, as duas operações bloqueantes do código do servidor precisam ser movidas para loops em threads separadas.

Código do servidor modificado:

void IniciarServidor()
{
    //1 Criar objeto Socket
    servidorSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

    //2 Associar IP e porta
    IPAddress ip = IPAddress.Parse("127.0.0.1");
    IPEndPoint pontoFinal = new IPEndPoint(ip, 50001);
    servidorSocket.Bind(pontoFinal);

    //3 Iniciar escuta, com limite de 10 clientes
    servidorSocket.Listen(10);

    // Iniciar nova thread para循环 aguardar novas conexões de clientes
    Task.Run(() => { AceitarConexoes(servidorSocket); });
}

void AceitarConexoes(Socket socket)
{
    while (true)
    {
        //4 [Bloqueante], aguardando conexão do cliente
        Socket novoSocket = socket.Accept();
        // Iniciar nova thread para循环 aguardar receber novos dados
        Task.Run(() => { ReceberDados(novoSocket); });
    }
}

void ReceberDados(Socket socketCliente)
{
    while (true)
    {
        //5 [Bloqueante], aguardando leitura de dados enviados pelo cliente
        byte[] dados = new byte[1024 * 1024];
        int tamanhoLido = socketCliente.Receive(dados, 0, dados.Length, SocketFlags.None);
        //6 Processar dados
        var mensagem = Encoding.UTF8.GetString(dados, 0, tamanhoLido);
    }
}