Hálózattal való munkához használtál standard…

A projekt és az igények függvényében használtam mind standard könyvtárakat, mind saját megoldásokat.

Standard könyvtárak:

Sockets API (BSD Sockets): Alacsony szintű API a TCP/IP kezeléséhez. Socketek létrehozására, kapcsolatok beállítására, adatok küldésére és fogadására használják.
Boost.Asio: Többplatformos könyvtár aszinkron bemenet/kimenet kezelésére, gyakran hálózati műveletekhez használják socketek, időzítők és más hálózati primitívek támogatása miatt.
libcurl: Kliens könyvtár adatok átviteléhez különböző protokollokon keresztül (HTTP, HTTPS, FTP stb.).

Saját megoldások:

Kifejlesztettem saját könyvtárakat és komponenseket, amikor a standard megoldások nem feleltek meg a projekt specifikus követelményeinek, például:

Magas teljesítmény és alacsony késleltetés.
Nem szokványos protokollok megvalósítása.
Szoros integráció más rendszerkomponensekkel.
Hibátűrő és skálázható megoldások, amelyek túlmutatnak a standard könyvtárak tipikus felhasználási esetein.

Példa saját megoldás használatára egy aszinkron TCP szerverhez:

// Egyszerűsített példa saját megoldással egy aszinkron TCP szerverre
#include <iostream>
#include <vector>
#include <asio.hpp> // Gyakran alapként használják szálpoolokhoz vagy aszinkron műveletekhez

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() {
        // Új kapcsolat várakozása
        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(); // Folytatja a kapcsolatok fogadását
        });
    }

    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) {
                // Az adatok feldolgozása
                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 << "Kivétel: " << e.what() << "\n";
//     }
//     return 0;
// }

Összehasonlító táblázat a megközelítésekről:

Megközelítés	Előnyök	Hátrányok	Alkalmazás
Standard könyvtárak	Gyors fejlesztés, bevált, jó dokumentáció, közösségi támogatás.	Korlátozott rugalmasság, esetleges overhead.	A legtöbb tipikus hálózati feladat.
Saját megoldások	Teljes kontroll, magas rugalmasság, optimalizáció specifikus feladatokra.	Magas fejlesztési és karbantartási költségek, hibák kockázata, tesztelés szükségessége.	Speciális teljesítményigények, nem szokványos protokollok, szoros integráció.

Általánosságban a megközelítés a projekt konkrét céljaitól és korlátaitól függött. Igyekeztem megtalálni az optimális egyensúlyt a kész megoldások és saját fejlesztések között, ahol ez indokolt volt.

Hálózattal való munkához használtál standard könyvtárakat vagy saját megoldásokat fejlesztettél?