Netly version 4 will be released soon, help validating the new way of interacting with netly. See more
|
β Your star is the light at the end of our tunnel. Lead us out of the darkness by starring Netly on GitHub. Star me please, I beg you! π |
powered by ALEC1O
Get basic information about this project called Netly
| Overview |
Netly is a powerful C# socket library that simplifies network communication. It supports HTTP, TCP, SSL/TLS, UDP, Reliable UDP (RUDP) and WebSocket protocols, making it ideal for building multiplayer games, chat applications, and more. |
||||
|---|---|---|---|---|---|
| Link's |
Repository: github.com/alec1o/netly Documentation: netly.docs.kezero.com |
||||
| Install |
|
||||
| Sponsor |
|
||||
| Supporter |
|
Notable changes
| 4.x.x | Development | HTTP client and server support | Reliable UDP (RUDP) client and server support | WebSocket client and server | Syntax and internal improvement | Code XML comments improvement | Documentation improvement by DocFx |
|---|---|---|---|---|---|---|---|
| 3.x.x | Stable | TCP with TLS/SSL support | UDP with connection (timeout response) | New Message Framing protocol and performance increase | Update for Byter 2.0 | Docsify as documentation framework | |
| 2.x.x | Legacy | TCP with Message Framing support | TCP and UDP performance increase | ||||
| 1.x.x | Legacy | TCP support | UDP Support |
Technical descriptions about integrations
| List of tested platforms |
|
|---|---|
| Dependencies |
|
| Build |
# 1. clone project
$ git clone "https://github.com/alec1o/Netly" netly
# 2. build project
$ dotnet build "netly/" -c Release -o "netly/bin/"
# NOTE:
# Netly.dll require Byter.dll because is Netly dependency
# Netly.dll and Byter.dll have on build folder <netly-path>/bin/ |
| Features |
|
Code highlights
| TCP |
π Clientusing 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); π Serverusing 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 }); |
|---|---|
| UDP |
π Clientusing 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); π Serverusing 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 });
|
| HTTP |
π Clientusing 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.alec1o.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();π Serverusing 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 path
server.Map.Get("/", async (req, res) => {
// Handle async: GET
})
server.Map.Post("/user", (req, res) => {
// Handle sync: POST
});
// map using dynamic URL
server.Map.Delete("/post/{userId}/group/{groupId}", async (req, res)) =>
{
string userId = req.Param["userId"];
string groupId = req.Param["groupId"];
// Handle async: Delete from dynamic URL path
});
server.Map.WebSocket("/echo", (req, ws) =>
{
// Handle websocket connection from path
});
/*
You can map:
* Get # get request
* Post # post request
* Delete # delete request
* Put # put request
* Patch # patch request
* Trace # trace request
* Options # options request
* Head # head request, (only head)
* All # all http nethod request
* WebSocket # websocket request
*/
/* Note: Callback return
true: next callback can be executed
false: next or others callback can't executed
Note: Middlewares is executed in added order
Global middleware have more priority than Local middleware
*/
server.Middleware.Add(async (req, res) => {
// e.g Verify user location
// success, execute next callback
return true;
});
// Global middleware
server.Middleware.Add(async (req, res) => {
// e.g verify banned IP
// success, execute next callback
return true;
});
// Local middleware
server.Middleware.Add("/admin", async (req, res) => {
// e.g Detect if the ip is allowed to access
if(Foo.Bar(req) == false)
{
if (Foo.Bar() == true)
{
await res.Redirect("https://www.example.com");
}
else
{
res.Header.Add("Content-Type", "application/json;charset=UTF-8");
await res.Send(404, "Response Content Here");
}
}
// fail, stop and close connection if is opened
return false;
});
// Local Middleware
server.Middleware.Add("/dashboard", async (req, res) =>
{
// e.g Check session from cookies.
return Foo.Bar(req.Cookies);
}); |
| RUDP |
π Clientusing Netly;
RUDP.Client client = new RUDP.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, type) =>
{
printf("connection received a raw data");
});
client.On.Event((name, bytes, type) =>
{
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 }, RUDP.Unreliable);
client.To.Data("hello world", NE.Encoding.UTF8, RUDP.Reliable);
// send event if connected
client.To.Event("name", new byte[2] { 128, 255 }, RUDP.Unreliable);
client.To.Event("name", "hello world", NE.Encoding.UTF8, RUDP.Reliable);π Serverusing Netly;
RUDP.Server server = new RUDP.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, type) =>
{
if (type == RUDP.Reliable) { ... }
else if (type == RUDP.Unreliable) { ... }
else { /* NOTE: it's imposible */ }
printf("client received a raw data");
});
client.On.Event((name, type) =>
if (type == RUDP.Reliable) { ... }
else if (type == RUDP.Unreliable) { ... }
else { /* NOTE: it's imposible */ }
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", RUDP.Unreliable);
server.To.DataBroadcast(new byte[] { 1, 2, 3 }, RUDP.Reliable);
// broadcast event (netly event) for all connected client
server.To.EventBroadcast("event name", "text buffer", RUDP.Unreliable);
server.To.EventBroadcast("event name", new byte[] { 1, 2, 3 }, RUDP.Reliable); |
| WebSocket |
π Clientusing Netly;
HTTP.WebSocket client = new HTTP.WebSocket();client.On.Open(() =>
{
// websocket connection opened
});
client.On.Close(() =>
{
// websocket connection closed
});
client.On.Error((exception) =>
{
// error on open websocket connectin
});
client.On.Data((bytes, type) =>
{
if (type == HTTP.Binary) { ... }
else if (type == HTTP.Text) { ... }
else { /* NOTE: it's imposible */ }
// raw data received from server
});
client.On.Event((name, bytes, type) =>
{
if (type == HTTP.Binary) { ... }
else if (type == HTTP.Text) { ... }
else { /* NOTE: it's imposible */ }
// event received from server
});
client.On.Modify((wsSocket) =>
{
// modify websocket socket
});// open websocket client connection
client.To.Open(new Uri("ws://127.0.0.1:8080/echo"));
// close websocket client connection
client.To.Close();
// send raw data for server
// text message
client.To.Data("my message", HTTP.Text);
// binnary message
client.To.Data(NE.GetBytes("my buffer"), HTTP.Binary);
// send event (netly event) for server
// text message
client.To.Event("event name", "my message", HTTP.Text);
// binnary message
client.To.Data("event name", NE.GetBytes("my buffer"), HTTP.Binary); π Serverusing Netly;
using Netly.Interfaces;
HTTP.Server server = new HTTP.Server();
IHTTP.WebSocket[] Clients = server.WebSocketClients;server.Map.WebSocket("/chat/{token}", async (req, ws) =>
{
// Accept websocket from dynamic path
string token = req.Params["token"];
// validate websocket connection from params
if (Foo.Bar(token) == false)
{
ws.To.Close();
}
ws.On.Modify(...);
ws.On.Open(...);
ws.On.Close(...);
ws.On.Data(...);
ws.On.Event(...);
});
server.Map.Websocket("/echo", (req, ws) =>
{
// Handle websocket on /echo path
ws.On.Modify((wsSocket) =>
{
// modify server-side websocket ocket
});
ws.On.Open(() =>
{
// server-side websocket connection opened
});
ws.On.Close(() =>
{
// server-side websocket connection closed
});
ws.On.Data((bytes, type) =>
{
if (type == HTTP.Binary) { ... }
else if (type == HTTP.Text) { ... }
else { /* NOTE: it's imposible */ }
// server-side websocket received raw data
});
ws.On.Event((name, bytes, type) =>
{
if (type == HTTP.Binary) { ... }
else if (type == HTTP.Text) { ... }
else { /* NOTE: it's imposible */ }
// server-side websocket received event
});
});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();// open websocket client connection
server.To.Open(new Uri("ws://127.0.0.1:8080/echo"));
// close websocket client connection
server.To.Close();
// broadcast raw data for all connected websocket socket
// text message
server.To.WebsocketDataBroadcast("my message", HTTP.Text);
// binnary message
server.To.WebsocketDataBroadcast(NE.GetBytes("my buffer"), HTTP.Binary);
// broadcast event (netly event) for all connected websocket socket
// text message
server.To.WebsocketEventBroadcast("event name", "my message", HTTP.Text);
// binnary message
server.To.WebsocketEventBroadcast("event name", NE.GetBytes("my buffer"), HTTP.Binary);
|
Integration and interaction example codes
| Standard |
π Consoleusing System;
using Netly;
public class Program
{
private static void Main(string[] args)
{
UDP.Client client = new UDP.Client();
client.On.Open(() =>
{
Console.WriteLine(<some-text-here>);
};
client.On.Close(() =>
{
Console.WriteLine(<some-text-here>);
};
client.On.Error((exception) =>
{
Console.WriteLine(<some-text-here>);
};
while(true)
{
if(!client.IsOpened)
{
client.To.Open(new Host("1.1.1.1", 1111));
}
else
{
Console.WriteLine("Message: ");
string message = Console.ReadLine();
client.To.Data(message ?? "No message.", NE.Encoding.UTF8);
}
}
}
} |
|---|---|
| Flax Engine |
π Scriptusing System;
using FlaxEngine;
using Netly;
public class Example : Script
{
public string message;
internal UDP.Client client;
public override void Awake()
{
client = new UDP.Client();
client.On.Open(() =>
{
Debug.Log(<some-text-here>);
};
client.On.Close(() =>
{
Debug.Log(<some-text-here>);
};
client.On.Error((exception) =>
{
Debug.Log(<some-text-here>);
};
}
public override void Start()
{
client.To.Open(new Host("1.1.1.1", 1111));
}
public override void Update()
{
if(!client.IsOpened)
{
client.To.Open(new Host("1.1.1.1", 1111));
}
else
{
if (Input.GetKeyDown(KeyCode.Space))
{
client.To.Data(message ?? "No message.", NE.Encoding.UTF8);
}
}
}
} |
| Unity Engine |
π MonoBehaviourusing System;
using FlaxEngine;
using Netly;
public class Example : MonoBehaviour
{
public string message;
internal UDP.Client client;
private void Awake()
{
client = new UDP.Client();
client.On.Open(() =>
{
Debug.Log(<some-text-here>);
};
client.On.Close(() =>
{
Debug.Log(<some-text-here>);
};
client.On.Error((exception) =>
{
Debug.Log(<some-text-here>);
};
}
private void Start()
{
client.To.Open(new Host("1.1.1.1", 1111));
}
private void Update()
{
if(!client.IsOpened)
{
client.To.Open(new Host("1.1.1.1", 1111));
}
else
{
if (Input.GetKeyDown(KeyCode.Space))
{
client.To.Data(message ?? "No message.", NE.Encoding.UTF8);
}
}
}
} |
| WARNING: |
You should never initialize events in an uncontrolled loop, (**.On) stores functions that will be
called when something happens and these functions only need to be initialized once. Understand,
It doesn't mean that every event will only have one callback attached to it,
but it means not to keep calling (**.On) frequently like in Loops.
See examples below of good and bad use.
For methods (**.To) there is an internal barrier that limits things like (trying to open or close connections several times, sending data with a disconnected socket, ...) although these methods do not cause problems when called in a loop, it is always good have the action and state in sync, for example only sending data when confirming that the connection is open. π Codeusing System;
using Netly;
private HTTP.WebSocket ws;// OK
private void Init()
{
ws.On.Open(() => { ... });
ws.On.Event((name, bytes) => { ... });
ws.On.Event((name, bytes) =>
{
if (name == "foo") { ... }
});
ws.On.Event((name, bytes) =>
{
if (name == "bar") { ... }
});
}// BAD
public void Loop()
{
client.To.Open(...); // [OK]
client.To.Data(...); // [OK]
client.To.Event(...); // [OK]
client.To.Close(...); // [OK]
ws.On.Open(() => { ... }); // [NEVER IN LOOP]
ws.On.Close(() => { ... }); // [NEVER IN LOOP]
ws.On.Data((bytes) => { ... }); // [NEVER IN LOOP]
ws.On.Error((exception) => { ... }); // [NEVER IN LOOP]
ws.On.Event((name, bytes) => { ... }); // [NEVER IN LOOP]
} |
![dependabot[bot] avatar](https://avatars.githubusercontent.com/in/29110?v=4 "dependabot[bot]")
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent