Haben Sie Standardbibliotheken verwendet oder eigene…

Ich habe sowohl Standardbibliotheken als auch eigene Lösungen verwendet, abhängig vom Projekt und den Anforderungen.

Standardbibliotheken:

Sockets API (BSD Sockets): Niedrigstufige API für die Arbeit mit TCP/IP. Wird zum Erstellen von Sockets, Herstellen von Verbindungen, Senden und Empfangen von Daten verwendet.
Boost.Asio: Plattformübergreifende Bibliothek für asynchrone Ein- und Ausgabe, die häufig für Netzwerkarbeiten genutzt wird, dank Unterstützung für Sockets, Timer und andere Netzprimitive.
libcurl: Client-Bibliothek für die Datenübertragung über verschiedene Protokolle (HTTP, HTTPS, FTP usw.).

Eigene Lösungen:

Ich habe eigene Bibliotheken und Komponenten entwickelt, wenn die Standardlösungen nicht die spezifischen Anforderungen des Projekts erfüllten, wie:

Hohe Leistung und niedrige Latenz.
Notwendigkeit, nicht standardmäßige Protokolle zu implementieren.
Enge Integration mit anderen Systemkomponenten.
Anforderungen an Fehlertoleranz und Skalierbarkeit, die über die typischen Anwendungsfälle der Standardbibliotheken hinausgehen.

Beispiel für die Verwendung einer eigenen Lösung für einen asynchronen TCP-Server:

// Vereinfachtes Beispiel für einen eigenen asynchronen TCP-Server
#include <iostream>
#include <vector>
#include <asio.hpp> // Wird häufig als Basis für Thread-Pools oder asynchrone Operationen verwendet

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() {
        // Warten auf eine neue Verbindung
        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(); // Fortsetzen des Akzeptierens von Verbindungen
        });
    }

    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) {
                // Verarbeiten der empfangenen Daten
                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;
// }

Vergleich der Ansätze:

Ansatz	Vorteile	Nachteile	Anwendung
Standardbibliotheken	Schnelle Entwicklung, bewährt, gute Dokumentation, Community-Support.	Eingeschränkte Flexibilität, möglicher Overhead.	Die meisten typischen Netzwerkaufgaben.
Eigene Lösungen	Volle Kontrolle, hohe Flexibilität, Optimierung für spezifische Aufgaben.	Hohe Entwicklungs- und Wartungskosten, Fehleranfälligkeit, Testbedarf.	Spezifische Leistungsanforderungen, nicht-standardisierte Protokolle, enge Integration.

Im Allgemeinen hing die Wahl vom Projekt, den Zielen und Beschränkungen ab. Ich versuchte, die optimale Balance zwischen der Nutzung fertiger Lösungen und der Entwicklung eigener Lösungen zu finden, wenn dies gerechtfertigt war.

Haben Sie Standardbibliotheken verwendet oder eigene Lösungen für die Netzwerkarbeit entwickelt?