Pentru a lucra cu rețeaua, ați folosit biblioteci standard sau ați dezvoltat soluții proprii?

Am folosit atât biblioteci standard, cât și soluții proprii, în funcție de proiect și cerințe.

Biblioteci standard:

• Sockets API (BSD Sockets): API de nivel scăzut pentru lucrul cu TCP/IP. Folosit pentru crearea de socket-uri, stabilirea conexiunilor, trimiterea și primirea datelor.
• Boost.Asio: Bibliotecă multiplatformă pentru operații asincrone de intrare/ieșire, adesea utilizată pentru rețea datorită suportului pentru socket-uri, temporizatoare și alte primitive de rețea.
• libcurl: Bibliotecă client pentru transferul de date prin diferite protocoale (HTTP, HTTPS, FTP etc.).

Soluții proprii:

Am dezvoltat biblioteci și componente proprii atunci când soluțiile standard nu satisfăceau cerințele specifice ale proiectului, cum ar fi:

• Performanță ridicată și latență scăzută.
• Necesitatea implementării unor protocoale non-standard.
• Integrare strânsă cu alte componente ale sistemului.
• Cerințe de toleranță la erori și scalabilitate care depășesc scenariile tipice de utilizare a bibliotecilor standard.

Exemplu de utilizare a unei soluții proprii pentru un server TCP asincron:

// Exemplu simplificat de server TCP asincron cu soluție proprie
#include <iostream>
#include <vector>
#include <asio.hpp> // Frecvent utilizat ca bază pentru pool-uri de fire sau operații 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() {
        // Așteptare pentru o nouă conexiune
        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(); // Continuă acceptarea conexiunilor
        });
    }

    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) {
                // Procesarea datelor primite
                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 << "Eroare: " << e.what() << "\n";
//     }
//     return 0;
// }

Tabel comparativ al abordărilor:

Abordare	Avantaje	Dezavantaje	Aplicație
Biblioteci standard	Dezvoltare rapidă, dovedite, documentație bună, suport comunitar.	Flexibilitate limitată, posibil overhead.	Majoritatea sarcinilor de rețea tipice.
Soluții proprii	Control complet, flexibilitate ridicată, optimizare pentru sarcini specifice.	Costuri ridicate de dezvoltare și întreținere, risc de erori, necesită teste.	Cerințe specifice de performanță, protocoale non-standard, integrare strânsă.

În general, abordarea depindea de proiectul specific, de scopurile și constrângerile sale. Am încercat să găsesc un echilibru optim între utilizarea soluțiilor gata făcute și dezvoltarea propriilor soluții, acolo unde a fost justificat.