Heeft u standaardbibliotheken gebruikt of eigen…

Ik heb zowel standaardbibliotheken als eigen oplossingen gebruikt, afhankelijk van het project en de vereisten.

Standaardbibliotheken:

Sockets API (BSD Sockets): Laag-niveau API voor TCP/IP-werking. Gebruikt voor het maken van sockets, het opzetten van verbindingen, het verzenden en ontvangen van gegevens.
Boost.Asio: Cross-platform bibliotheek voor asynchrone invoer/uitvoer, vaak gebruikt voor netwerkwerking vanwege ondersteuning voor sockets, timers en andere netwerkprimitive.
libcurl: Clientbibliotheek voor gegevensoverdracht via verschillende protocollen (HTTP, HTTPS, FTP, etc.).

Eigen oplossingen:

Ontwikkelde eigen bibliotheken en componenten wanneer standaardoplossingen niet voldeden aan de specifieke eisen van het project, zoals:

Hoge prestaties en lage latentie.
Noodzaak voor implementatie van niet-standaard protocollen.
Nauwe integratie met andere systeemcomponenten.
Eisen aan fouttolerantie en schaalbaarheid die verder gaan dan de standaardgebruiksscenario's.

Voorbeeld van gebruik van een eigen oplossing voor een asynchrone TCP-server:

// Vereenvoudigd voorbeeld van een asynchrone TCP-server met eigen oplossing
#include <iostream>
#include <vector>
#include <asio.hpp> // Vaak gebruikt als basis voor threadpools of asynchrone operaties

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() {
        // Wachten op nieuwe verbinding
        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(); // Blijft verbindingen accepteren
        });
    }

    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) {
                // Verwerking van ontvangen gegevens
                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;
// }

Vergelijkingstabel van benaderingen:

Benadering	Voordelen	Nadelen	Toepassing
Standaardbibliotheken	Snelle ontwikkeling, bewezen, goede documentatie, community-ondersteuning.	Beperkte flexibiliteit, mogelijke overhead.	De meeste standaard netwerk taken.
Eigen oplossingen	Volledige controle, hoge flexibiliteit, optimalisatie voor specifieke taken.	Hoge ontwikkelings- en onderhoudskosten, risico op fouten, testvereisten.	Specifieke prestatie-eisen, niet-standaard protocollen, nauwe integratie.

Over het algemeen hing de aanpak af van het specifieke project, de doelen en beperkingen. Ik streefde ernaar een optimale balans te vinden tussen het gebruik van kant-en-klare oplossingen en het ontwikkelen van eigen oplossingen, waar dat gerechtvaardigd was.

Heeft u standaardbibliotheken gebruikt of eigen oplossingen ontwikkeld voor het werken met het netwerk?