Czy do pracy z siecią używałeś standardowych…

Używałem zarówno bibliotek standardowych, jak i własnych rozwiązań, w zależności od projektu i wymagań.

Biblioteki standardowe:

Sockets API (BSD Sockets): Niskopoziowe API do pracy z TCP/IP. Używane do tworzenia gniazd, ustanawiania połączeń, wysyłania i odbierania danych.
Boost.Asio: Wieloplatformowa biblioteka do asynchronicznego wejścia/wyjścia, często używana do pracy w sieci dzięki obsłudze gniazd, timerów i innych prymitywów sieciowych.
libcurl: Biblioteka klienta do przesyłania danych przez różne protokoły (HTTP, HTTPS, FTP itp.).

Rozwiązania własne:

Opracowałem własne biblioteki i komponenty w przypadkach, gdy standardowe rozwiązania nie spełniały specyficznych wymagań projektu, takich jak:

Wysoka wydajność i niskie opóźnienia.
Konieczność implementacji niestandardowych protokołów.
Ścisła integracja z innymi komponentami systemu.
Wymagania dotyczące odporności na błędy i skalowalności wykraczające poza typowe scenariusze użycia bibliotek standardowych.

Przykład użycia własnego rozwiązania dla asynchronicznego serwera TCP:

// Uproszczony przykład własnego asynchronicznego serwera TCP
#include <iostream>
#include <vector>
#include <asio.hpp> // Często używany jako podstawa dla pul wątków lub operacji asynchronicznych

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() {
        // Oczekiwanie na nowe połączenie
        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(); // Kontynuuj akceptację połączeń
        });
    }

    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) {
                // Przetwarzanie odebranych danych
                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 << "Wyjątek: " << e.what() << "\n";
//     }
//     return 0;
// }

Porównanie podejść:

Podejście	Zalety	Wady	Zastosowanie
Biblioteki standardowe	Szybki rozwój, sprawdzone, dobra dokumentacja, wsparcie społeczności.	Ograniczona elastyczność, potencjalny narzut.	Większość typowych zadań sieciowych.
Rozwiązania własne	Pełna kontrola, wysoka elastyczność, optymalizacja pod konkretne zadania.	Wysoki koszt rozwoju i utrzymania, ryzyko błędów, konieczność testowania.	Wymagania dotyczące wydajności, niestandardowe protokoły, ścisła integracja.

Ogólnie, wybór zależał od projektu, celów i ograniczeń. Starałem się znaleźć optymalną równowagę między korzystaniem z gotowych rozwiązań a własnym rozwojem, tam gdzie było to uzasadnione.

Czy do pracy z siecią używałeś standardowych bibliotek, czy opracowałeś własne rozwiązania?