perf: improved networking code to use the new events

Shared/Network/Abstract/INetworkCommunicator.cs

@@ -1,4 +1,4 @@
-using System;
+using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Network;
 
@@ -6,8 +6,8 @@ public interface INetworkCommunicator
 {
     INetworkCommunicator Stop();
 
-    INetworkCommunicator SubscribeToPackets<T>(Action<T, string> callback);
-    INetworkCommunicator UnsubscribeFromPackets<T>(Action<T, string> callback);
+    INetworkCommunicator SubscribeToPackets<T>(Event<string, T>.EventHandler callback);
+    INetworkCommunicator UnsubscribeFromPackets<T>(Event<string, T>.EventHandler callback);
 }
 
 public interface INetworkCommunicatorClient : INetworkCommunicator

Shared/Network/Abstract/IPacketListenerServer.cs

@@ -2,5 +2,5 @@ namespace Syntriax.Engine.Network;
 
 public interface IPacketListenerServer<T> : INetworkEntity
 {
-    void OnServerPacketArrived(T packet, string from);
+    void OnServerPacketArrived(string sender, T packet);
 }

Shared/Network/LiteNetLib/LiteNetLibCommunicatorBase.cs

@@ -14,7 +14,7 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu
 {
     protected readonly NetPacketProcessor netPacketProcessor = new();
 
-    private readonly Dictionary<Type, List<Delegate>> listeners = [];
+    private readonly Dictionary<Type, Event<string, object>> listeners = [];
 
     public EventBasedNetListener Listener { get; private set; } = null!;
     public NetManager Manager { get; private set; } = null!;
@@ -33,11 +33,10 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu
 
     protected virtual void OnPacketArrived<T>(T packet, NetPeer peer) where T : INetworkPacket
     {
-        if (!listeners.TryGetValue(typeof(T), out List<Delegate>? delegates))
+        if (!listeners.TryGetValue(typeof(T), out Event<string, object>? @event))
             return;
 
-        foreach (Delegate @delegate in delegates)
-            @delegate.DynamicInvoke(packet, peer.Id.ToString());
+        @event.Invoke(peer.Id.ToString(), packet);
     }
 
     private void NetworkReceiveEvent(NetPeer peer, NetPacketReader reader, byte channel, DeliveryMethod deliveryMethod)
@@ -119,26 +118,28 @@ public abstract class LiteNetLibCommunicatorBase : UniverseObject, INetworkCommu
         netPacketProcessor.RegisterNestedType(Vector3DNetPacker.Write, Vector3DNetPacker.Read);
     }
 
-    public INetworkCommunicator SubscribeToPackets<T>(Action<T, string> callback)
+    public INetworkCommunicator SubscribeToPackets<T>(Event<string, T>.EventHandler callback)
     {
         Type type = typeof(T);
-        if (!listeners.TryGetValue(type, out List<Delegate>? delegates))
+        if (!listeners.TryGetValue(type, out Event<string, object>? @event))
         {
-            delegates = [];
-            listeners.Add(type, delegates);
+            @event = new();
+            listeners.Add(type, @event);
         }
 
-        delegates.Add(callback);
+        @event.AddListener(EventDelegateWrapper(callback));
         return this;
     }
 
-    public INetworkCommunicator UnsubscribeFromPackets<T>(Action<T, string> callback)
+    public INetworkCommunicator UnsubscribeFromPackets<T>(Event<string, T>.EventHandler callback)
     {
         Type type = typeof(T);
-        if (!listeners.TryGetValue(type, out List<Delegate>? delegates))
+        if (!listeners.TryGetValue(type, out Event<string, object>? @event))
             return this;
 
-        delegates.Remove(callback);
+        @event.RemoveListener(EventDelegateWrapper(callback));
         return this;
     }
+
+    private static Event<string, object>.EventHandler EventDelegateWrapper<T>(Event<string, T>.EventHandler callback) => (sender, @object) => callback.Invoke(sender, (T)@object);
 }

Shared/Network/NetworkManager.cs

@@ -28,8 +28,8 @@ public class NetworkManager : UniverseObject, INetworkManager
         }
     }
 
-    private readonly Dictionary<Type, Dictionary<string, PacketListenerData>> clientPacketListeners = [];
-    private readonly Dictionary<Type, Dictionary<string, PacketListenerData>> serverPacketListeners = [];
+    private readonly Dictionary<Type, Dictionary<string, Event<string, object>>> clientPacketListeners = [];
+    private readonly Dictionary<Type, Dictionary<string, Event<string, object>>> serverPacketListeners = [];
 
     private readonly Dictionary<string, INetworkEntity> _networkEntities = [];
     public IReadOnlyDictionary<string, INetworkEntity> NetworkEntities => _networkEntities;
@@ -44,6 +44,7 @@ public class NetworkManager : UniverseObject, INetworkManager
         _networkEntityCollector.OnCollected.AddListener(OnCollected);
         _networkEntityCollector.OnRemoved.AddListener(OnRemoved);
     }
+
     private void CacheDelegates()
     {
         // Find network packets implementing INetworkPacket
@@ -57,7 +58,7 @@ public class NetworkManager : UniverseObject, INetworkManager
         {
             MethodInfo genericOnPacketArrivedMethod = onPacketArrivedMethod.MakeGenericMethod(packetType);
 
-            Type genericDelegateType = typeof(Action<,>).MakeGenericType(packetType, typeof(string));
+            Type genericDelegateType = typeof(Event<,>.EventHandler).MakeGenericType(typeof(string), packetType);
             Delegate genericPacketReceivedDelegate = Delegate.CreateDelegate(genericDelegateType, this, genericOnPacketArrivedMethod);
 
             delegates.Add((packetType, genericPacketReceivedDelegate));
@@ -90,34 +91,34 @@ public class NetworkManager : UniverseObject, INetworkManager
         }
     }
 
-    private void OnPacketReceived<T>(T entityDataPacket, string fromClientId)
+    private void OnPacketReceived<T>(string senderClientId, T entityDataPacket)
     {
         Type packetType = typeof(T);
 
         if (entityDataPacket is IEntityNetworkPacket entityPacket)
         {
             if (networkCommunicator is INetworkCommunicatorClient)
-                if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, PacketListenerData>? clientListeners))
-                    if (clientListeners.TryGetValue(entityPacket.EntityId, out PacketListenerData clientListenerData))
-                        clientListenerData.ListenerMethod.Invoke(clientListenerData.Object, [entityDataPacket]);
+                if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? clientListeners))
+                    if (clientListeners.TryGetValue(entityPacket.EntityId, out Event<string, object>? clientListenerData))
+                        clientListenerData.Invoke(senderClientId, entityDataPacket!);
 
             if (networkCommunicator is INetworkCommunicatorServer)
-                if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, PacketListenerData>? serverListeners))
-                    if (serverListeners.TryGetValue(entityPacket.EntityId, out PacketListenerData serverListenerData))
-                        serverListenerData.ListenerMethod.Invoke(serverListenerData.Object, [entityDataPacket, fromClientId]);
+                if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? serverListeners))
+                    if (serverListeners.TryGetValue(entityPacket.EntityId, out Event<string, object>? serverListenerData))
+                        serverListenerData.Invoke(senderClientId, entityDataPacket!);
 
             return;
         }
 
         if (networkCommunicator is INetworkCommunicatorClient)
-            if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, PacketListenerData>? clientListeners))
-                foreach ((string id, PacketListenerData clientListenerData) in clientListeners)
-                    clientListenerData.ListenerMethod.Invoke(clientListenerData.Object, [entityDataPacket]);
+            if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? clientListeners))
+                foreach ((string id, Event<string, object> clientListenerData) in clientListeners)
+                    clientListenerData.Invoke(senderClientId, entityDataPacket!);
 
         if (networkCommunicator is INetworkCommunicatorServer)
-            if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, PacketListenerData>? serverListeners))
-                foreach ((string id, PacketListenerData serverListenerData) in serverListeners)
-                    serverListenerData.ListenerMethod.Invoke(serverListenerData.Object, [entityDataPacket, fromClientId]);
+            if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? serverListeners))
+                foreach ((string id, Event<string, object> serverListenerData) in serverListeners)
+                    serverListenerData.Invoke(senderClientId, entityDataPacket!);
     }
 
     private void OnCollected(IBehaviourCollector<INetworkEntity> sender, IBehaviourCollector<INetworkEntity>.BehaviourCollectedArguments args)
@@ -132,13 +133,15 @@ public class NetworkManager : UniverseObject, INetworkManager
             Type clientListenerParameterType = clientListenerType.GetGenericArguments().First();
             MethodInfo clientListenerReceiveMethod = clientListenerType.GetMethods().First(m => m.Name == nameof(IPacketListenerClient<INetworkEntity>.OnClientPacketArrived));
 
-            if (!clientPacketListeners.TryGetValue(clientListenerParameterType, out Dictionary<string, PacketListenerData>? clientListeners))
+            if (!clientPacketListeners.TryGetValue(clientListenerParameterType, out Dictionary<string, Event<string, object>>? clientListeners))
             {
                 clientListeners = [];
                 clientPacketListeners.Add(clientListenerParameterType, clientListeners);
             }
 
-            clientListeners.Add(collectedBehaviour.Id, new(collectedBehaviour, clientListenerReceiveMethod));
+            Event<string, object> clientListenerEvent = new();
+            clientListenerEvent.AddListener((sender, @object) => clientListenerReceiveMethod.Invoke(collectedBehaviour, [@object]));
+            clientListeners.Add(collectedBehaviour.Id, clientListenerEvent);
         }
 
         foreach (Type serverListenerType in collectedBehaviour.GetType().GetInterfaces().Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPacketListenerServer<>)))
@@ -146,13 +149,15 @@ public class NetworkManager : UniverseObject, INetworkManager
             Type serverListenerParameterType = serverListenerType.GetGenericArguments().First();
             MethodInfo serverListenerReceiveMethod = serverListenerType.GetMethods().First(m => m.Name == nameof(IPacketListenerServer<INetworkEntity>.OnServerPacketArrived));
 
-            if (!serverPacketListeners.TryGetValue(serverListenerParameterType, out Dictionary<string, PacketListenerData>? serverListeners))
+            if (!serverPacketListeners.TryGetValue(serverListenerParameterType, out Dictionary<string, Event<string, object>>? serverListeners))
             {
                 serverListeners = [];
                 serverPacketListeners.Add(serverListenerParameterType, serverListeners);
             }
 
-            serverListeners.Add(collectedBehaviour.Id, new(collectedBehaviour, serverListenerReceiveMethod));
+            Event<string, object> serverListenerEvent = new();
+            serverListenerEvent.AddListener((sender, @object) => serverListenerReceiveMethod.Invoke(collectedBehaviour, [sender, @object]));
+            serverListeners.Add(collectedBehaviour.Id, serverListenerEvent);
         }
     }
 
@@ -167,10 +172,4 @@ public class NetworkManager : UniverseObject, INetworkManager
         _networkEntityCollector.Assign(universe);
         NetworkCommunicator = this.GetRequiredUniverseObjectInParent<INetworkCommunicator>();
     }
-
-    private record struct PacketListenerData(object Object, MethodInfo ListenerMethod)
-    {
-        public static implicit operator (object @object, MethodInfo listenerMethod)(PacketListenerData value) => (value.Object, value.ListenerMethod);
-        public static implicit operator PacketListenerData((object @object, MethodInfo listenerMethod) value) => new(value.@object, value.listenerMethod);
-    }
 }