Netly

using Netly;

TCP.Client client = new TCP.Client(framing: true);

client.On.Open(() =>
{
    printf(\"connection opened\");
});

client.On.Close(() =>
{
    printf(\"connetion closed\");
});

client.On.Error((exception) =>
{
    printf(\"connection erro on open\");
});

client.On.Data((bytes) =>
{
    printf(\"connection receive a raw data\");
});

client.On.Event((name, data) =>
{
    printf(\"connection receive a event\");
});

client.On.Modify((socket) =>
{
    printf(\"called before try open connection.\");
});

client.On.Encryption((certificate, chain, errors) =>
{
    // Only if client.IsEncrypted is enabled
    printf(\"validate ssl/tls certificate\");
    // return true if certificate is valid
    return true;
});

// open connection if closed
client.To.Open(new Host(\"127.0.0.1\", 8080));

// close connection if opened
client.To.Close();

// send raw data if connected
client.To.Data(new byte[2] { 128, 255 });
client.To.Data(\"hello world\", NE.Encoding.UTF8);

// send event if connected
client.To.Event(\"name\", new byte[2] { 128, 255 });
client.To.Event(\"name\", \"hello world\", NE.Encoding.UTF8);

// enable encryption (must call before client.To.Open)
client.To.Encryption(true);

using Netly;

TCP.Server server = new TCP.Server(framing: true);

server.On.Open(() =>
{
    printf(\"connection opened\");
});

server.On.Close(() =>
{
    printf(\"connection closed\");
});

server.On.Error((exception) =>
{
    printf(\"connection error on open\");
});

server.On.Accept((client) =>
{
    client.On.Modify((socket) =>
    {
        printf(\"modify client socket e.g Enable NoDelay\");
    });

    client.On.Open(() =>
    {
        printf(\"client connected\");
    });

    client.On.Data((bytes) =>
    {
        printf(\"client receive a raw data\");
    });

    client.On.Event((name, bytes) =>
    {
        printf(\"client receive a event\");
    });

    client.On.Close(() =>
    {
        printf(\"client disconnected\");
    });
});

server.On.Modify((socket) =>
{
    printf(\"called before try open connection.\");
});

// open connection
server.To.Open(new Host(\"1.1.1.1\", 1111));

// close connection
server.To.Close();

// enable encryption support (must called before server.To.Open)
server.To.Encryption(enable: true, @mypfx, @mypfxpassword, SslProtocols.Tls12);

// broadcast raw data for all connected client
server.To.DataBroadcast(\"text buffer\");
server.To.DataBroadcast(new byte[] { 1, 2, 3 });

// broadcast event (netly event) for all connected client
server.To.EventBroadcast(\"event name\", \"text buffer\");
server.To.EventBroadcast(\"event name\", new byte[] { 1, 2, 3 });

using Netly;

UDP.Client client = new UDP.Client();

client.On.Open(() =>
{
    printf(\"connection opened\");
});

client.On.Close(() =>
{
    printf(\"connection closed\");
});

client.On.Error((exception) =>
{
    printf(\"connection error on open\");
});

client.On.Data((bytes) =>
{
    printf(\"connection received a raw data\");
});

client.On.Event((name, eventBytes) =>
{
    printf(\"connection received a event\");
});

client.On.Modify((socket) =>
{
   printf(\"called before try open connection.\");
});

// open connection if closed
client.To.Open(new Host(\"127.0.0.1\", 8080));

// close connection if opened
client.To.Close();

// send raw data if connected
client.To.Data(new byte[2] { 128, 255 });
client.To.Data(\"hello world\", NE.Encoding.UTF8);

// send event if connected
client.To.Event(\"name\", new byte[2] { 128, 255 });
client.To.Event(\"name\", \"hello world\", NE.Encoding.UTF8);

using Netly;

UDP.Server server = new UDP.Server();

server.On.Open(() =>
{
    printf(\"connection opened\");
});

server.On.Close(() =>
{
    printf(\"connection closed\");
});

server.On.Error((exception) =>
{
    printf(\"connection error on open\");
});

server.On.Accept((client) =>
{
    client.On.Open(() =>
    {
        printf(\"client connected\");
    });

    client.On.Close(() =>
    {
        // Only if use connection is enabled.
        printf(\"client disconnected\");
    });

    client.On.Data((bytes) =>
    {
        printf(\"client received a raw data\");
    });

    client.On.Event((name, bytes) =>
    {
        printf(\"client received a event\");
    });
});

// open connection
server.To.Open(new Host(\"127.0.0.1\", 8080));

// close connection
server.To.Close();

// broadcast raw data for all connected client
server.To.DataBroadcast(\"text buffer\");
server.To.DataBroadcast(new byte[] { 1, 2, 3 });

// broadcast event (netly event) for all connected client
server.To.EventBroadcast(\"event name\", \"text buffer\");
server.To.EventBroadcast(\"event name\", new byte[] { 1, 2, 3 });

using Netly;

HTTP.Client client = new HTTP.Client();

// add http header for request
client.Headers.Add(\"Content-Type\", \"json\");
client.Headers.Add(\"Token\", \"ImGui.h\");

// add http url queries e.g: https://www.*al**ec1o.com/?page=about&version=4
client.Queries.Add(\"page\", \"about\");
client.Queries.Add(\"version\", \"4\");

// set request timeout (ms) default 15s (15000ms), 0 or negative value means infinite timeout.
client.Timeout = 6000; // 6s

// is opened: while is requesting
bool isFetching = client.IsOpened;

HttpClient http = null;

// called before try connect to server
// modify the HttpClient object
client.On.Modify((HttpClient instance) =>
{
    http = instance;
});

// connection is opened and fetch server.
client.On.Open((response) =>
{
    // you can use \"http\" instance on this scope (isn\'t null)
    if (http.<foo> == <bar>) { ... }
});

// erro on fetch, it can be timeout or whatever error
// but if you receives error it mean the operation is called or done
client.On.Error((Exception exception) =>
{
    Ny.Logger.PushError(exception);
});

// connection is closed with fetch server.
client.On.Close(() =>
{
     if (http.<bar> == <foo>) { ... }
});

// used to fetch a server
client.To.Open(\"method e.g GET\", \"url\", \"body, allow null\");

// used for cancel opened request
client.To.Close();

using Netly;

HTTP.Server server = new HTTP.Server();

// return true if server is serve http context
bool isServe = server.IsOpened;

server.On.Open(() =>
{
    // http server opened
});
server.On.Close(() =>
{
    // http server closed
});

server.On.Error((exception) =>
{
    // http server open error
});

server.On.Modify((httpListener) =>
{
    // HttpListener instance, called before try open connection.
});

// Open http server connection
server.To.Open(new Uri(\"http://127.**0.*0.1:8080/\"));

// Close http server connection
server.To.Close();

Map