Per lavorare con la rete, hai utilizzato librerie…

Ho utilizzato sia librerie standard che soluzioni proprie, a seconda del progetto e dei requisiti.

Librerie standard:

Sockets API (BSD Sockets): API di basso livello per lavorare con TCP/IP. Usata per creare socket, stabilire connessioni, inviare e ricevere dati.
Boost.Asio: Libreria multipiattaforma per input/output asincrono, spesso usata per lavori di rete grazie al supporto di socket, timer e altre primitive di rete.
libcurl: Libreria client per il trasferimento di dati tramite vari protocolli (HTTP, HTTPS, FTP, ecc.).

Soluzioni proprie:

Ho sviluppato librerie e componenti propri nei casi in cui le soluzioni standard non soddisfacevano requisiti specifici del progetto, come:

Alte prestazioni e basse latenze.
Necessità di implementare protocolli non standard.
Integrazione stretta con altri componenti del sistema.
Requisiti di tolleranza ai guasti e scalabilità che superano gli scenari tipici di utilizzo delle librerie standard.

Esempio di utilizzo di una soluzione propria per un server TCP asincrono:

// Esempio semplificato di un server TCP asincrono proprio
#include <iostream>
#include <vector>
#include <asio.hpp> // Spesso usato come base per pool di thread o operazioni asincrone

class TcpServer {
public:
    TcpServer(asio::io_context& io_context, short port)
        : acceptor_(io_context, asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port)) {
        start_accept();
    }

private:
    void start_accept() {
        // Attesa di una nuova connessione
        auto new_connection = std::make_shared<TcpConnection>(acceptor_.get_executor());
        acceptor_.async_accept(new_connection->socket(),
            [this, new_connection](const asio::error_code& error) {
            if (!error) {
                new_connection->start();
            }
            start_accept(); // Continuare ad accettare connessioni
        });
    }

    asio::ip::tcp::acceptor acceptor_;
};

class TcpConnection : public std::enable_shared_from_this<TcpConnection> {
public:
    TcpConnection(asio::executor ex) : socket_(ex) {}

    asio::ip::tcp::socket& socket() { return socket_; }

    void start() {
        do_read();
    }

private:
    void do_read() {
        auto self(shared_from_this());
        socket_.async_read_some(asio::buffer(data_, max_length),
            [self](const asio::error_code& error, size_t bytes_transferred) {
            if (!error) {
                // Elaborazione dati ricevuti
                self->do_write(bytes_transferred);
            }
        });
    }

    void do_write(size_t length) {
        auto self(shared_from_this());
        asio::async_write(socket_, asio::buffer(data_, length),
            [self](const asio::error_code& error, size_t /*bytes_transferred*/) {
            if (!error) {
                self->do_read();
            }
        });
    }

    asio::ip::tcp::socket socket_;
    enum { max_length = 1024 };
    char data_[max_length];
};
// int main() {
//     try {
//         asio::io_context io_context;
//         TcpServer server(io_context, 8080);
//         io_context.run();
//     } catch (std::exception& e) {
//         std::cerr << "Exception: " << e.what() << "\n";
//     }
//     return 0;
// }

Confronto tra approcci:

Approccio	Vantaggi	Svantaggi	Applicazione
Librerie standard	Sviluppo rapido, collaudato, buona documentazione, supporto della comunità.	Flessibilità limitata, possibile overhead.	La maggior parte dei compiti di rete tipici.
Soluzioni proprie	Controllo totale, alta flessibilità, ottimizzazione per compiti specifici.	Alto costo di sviluppo e manutenzione, rischio di errori, necessità di test.	Requisiti di prestazioni specifici, protocolli non standard, integrazione stretta.

In generale, la scelta dipendeva dal progetto, dai suoi obiettivi e restrizioni. Cercavo di trovare un equilibrio ottimale tra l'uso di soluzioni pronte e lo sviluppo di soluzioni proprie quando giustificato.

Per lavorare con la rete, hai utilizzato librerie standard o hai sviluppato soluzioni proprie?