Not to be confused as an implementation of ENet in C++, E++Net is a C# networking library built on top of ENet-CSharp, a C# port of ENet with additional features such as IPv6 support.
-
No manual data serialization required! Register a custom object, write your methods and properties, and add attributes to let E++Net know how to interact with them.
**Custom method parameter types unknown to E++Net can be registered. Game engines that don't support `new()` to construct a game object can specify a custom generator to make one properly.** -
Subscription based interest system! Clients only receive updates about objects (and their children) they have interest in. No wasted bandwidth on unnecessary data!
-
Tree hierarchy for objects! Objects can have as many children objects as you would like. You can reparent objects on the fly and clients automatically subscribe to new children objects.
**Network methods and properties are inherited from base types that declare them!** -
Snapshotting! E++Net keeps track of the last N "ticks" of the simulation for interpolation, extrapolation, and to offer a smooth and responsive experience for even the most high latency clients.
-
Security! E++Net allows you to implement your own authentication method for newly connected clients, limit what kinds of datagrams they can send, and automatically timeout clients that fail to identify themselves.
E++Net, by default, is server authoritative and clients only know about the remote server connection. Commands can only be sent by clients if the server explicitly allows it. -
Concurrency! E++Net leverages modern .NET features for high throughput message serialization and deserialization automatically.
-
Modular! E++Net is designed to be extendable, easy to maintain, and easy to turn features on and off via a JSON configuration or through code.
-
Flexible! Don't like a particular abstraction or service? The API is forgiving and allows changes from your assemblies. Extend an existing type and override existing methods to make it your own!
E++Net is a high performance, portable, and general-purpose UDP solution designed to abstract away the most frustrating aspects of multiplayer application development -- especially for games. As a multiplayer game developer myself, I was absolutely tired of constantly writing different serializables, unique packet or datagram types, and spending a ton of time designing a bunch of data plumbing -- it gets even worse when concurrency is involved! Sometimes writing helper classes or extensions methods would save me some work of course, but, in other libraries you might accumulate a bunch of garbage or wasted CPU cycles because you did something the library or framework developer didn't expect. The last thing I wanted to do was spend my precious free time doing data plumbing. E++Net is designed to do all the heavy lifting but leave enough flexibility for developers who need to do some fine-tuning.
Take the following pseudo code featuring a client-side implementation of a Player for example.
// The "Dist" flag dictates which distribution should use this implementation. The following
// attribute setup specifies that this class "PlayerClient" should only be used on clients.
[NetworkObject(Dist = Distribution.Client)]
class PlayerClient : ISimUnit {
// Players will have an integer health property which can be sent by the owner
// of the player object.
[NetworkProperty(NetworkFlags.Persistant | NetworkFlags.OwnerSend)]
public int Health { get; set; }
// Players will also require a position to be generated. The snapshot
// network flag tells E++Net to enable interpolation and extrapolation, and
// store the value of the getter along with the current snapshot time. Synchronization
// is done automatically and the snapshot flag implies persistance.
[NetworkMethod(NetworkFlags.Required | NetworkFlags.Snapshot)]
public void SetPosition(Vector3 position) {}
// Where's the attribute you ask? E++Net is smart enough to locate getter methods
// if they have an identical name to the setter except with "get" instead of "set".
public Vector3 GetPosition() {}
}E++Net will take care of the rest!
No! E++Net is a general purpose networking library with portability in mind. In the future, I intend on making demos or optional extension packages for specific game engines.
Yes! E++Net internally utilizes System.Threading.Channels for high throughput messaging.
E++Net leverages Microsoft's RecyclableMemoryStreams (memory stream pooling) and stack allocated byte arrays for datagram reading and writing. This means that E++Net does not create garbage when reading or writing from a datagram. E++Net only updates remote clients about objects and events they've subscribed to.
E++Net uses compiled expression trees to manipulate objects which is several orders of magnitude faster than standard reflection or an
Activator#CreateInstance()approach when generating objects. However, this comes as a tradeoff for slower startup times as time is needed to compile the necessary expressions for object generation and manipulation.
This project has been inspired by:
- Tanner Gooding Microsoft .NET Team - Architecture advice
- Stuart Turner - Architecture advice
- Brian Lach - For listening to my ramblings, rants, and giving advice
- Stanislav Denisov - Creator and Maintainer of C# port of ENet
- Lee Salzman - Creator of ENet (to my knowledge)