perf!: events refactored throughout all the project to use Event<> class

All delegate events are refactored to use the Event<TSender> and Event<TSender, TArgument> for performance issues regarding delegate events creating garbage, also this gives us better control on event invocation since C# Delegates did also create unnecessary garbage during Delegate.DynamicInvoke

Engine.Core/Helpers/Event.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+
+namespace Syntriax.Engine.Core;
+
+public class Event<TSender>
+{
+    private readonly List<EventHandler> listeners = new(8);
+
+    public void AddListener(EventHandler listener) => listeners.Add(listener);
+    public void RemoveListener(EventHandler listener) => listeners.Remove(listener);
+    public void Clear() => listeners.Clear();
+    public void Invoke(TSender argument)
+    {
+        for (int i = 0; i < listeners.Count; i++)
+            try { listeners[i].Invoke(argument); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{listeners[i].Method.DeclaringType?.FullName}.{listeners[i].Method.Name}({argument})";
+                Console.WriteLine($"Unexpected exception on invocation of method {methodCallRepresentation}:{Environment.NewLine}{exception.InnerException}");
+            }
+    }
+
+    public delegate void EventHandler(TSender sender);
+}
+
+public class Event<TSender, TArguments>
+{
+    private readonly List<EventHandler> listeners = new(8);
+
+    public void AddListener(EventHandler listener) => listeners.Add(listener);
+    public void RemoveListener(EventHandler listener) => listeners.Remove(listener);
+    public void Clear() => listeners.Clear();
+    public void Invoke(TSender sender, TArguments args)
+    {
+        for (int i = 0; i < listeners.Count; i++)
+            try { listeners[i].Invoke(sender, args); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{listeners[i].Method.DeclaringType?.FullName}.{listeners[i].Method.Name}({string.Join(", ", sender, args)})";
+                Console.WriteLine($"Unexpected exception on invocation of method {methodCallRepresentation}:{Environment.NewLine}{exception.InnerException}");
+            }
+    }
+
+    public delegate void EventHandler(TSender sender, TArguments args);
+}

Engine.Core/Helpers/Progression/IReadOnlyProgressionTracker.cs

@@ -2,12 +2,11 @@ namespace Syntriax.Engine.Core;
 
 public interface IReadOnlyProgressionTracker
 {
-    event ProgressionUpdatedEventHandler? OnUpdated;
-    event ProgressionEndedEventHandler? OnEnded;
+    Event<IReadOnlyProgressionTracker, ProgressionUpdatedArguments> OnUpdated { get; }
+    Event<IReadOnlyProgressionTracker> OnEnded { get; }
 
     float Progression { get; }
     string Status { get; }
 
-    delegate void ProgressionUpdatedEventHandler(IReadOnlyProgressionTracker sender, float previousProgression, string previousStatus);
-    delegate void ProgressionEndedEventHandler(IReadOnlyProgressionTracker sender);
+    readonly record struct ProgressionUpdatedArguments(float PreviousProgression, string PreviousStatus);
 }

Engine.Core/Helpers/Progression/ProgressionTracker.cs

@@ -2,8 +2,8 @@ namespace Syntriax.Engine.Core;
 
 public class ProgressionTracker : IProgressionTracker
 {
-    public event IReadOnlyProgressionTracker.ProgressionUpdatedEventHandler? OnUpdated = null;
-    public event IReadOnlyProgressionTracker.ProgressionEndedEventHandler? OnEnded = null;
+    public Event<IReadOnlyProgressionTracker, IReadOnlyProgressionTracker.ProgressionUpdatedArguments> OnUpdated { get; } = new();
+    public Event<IReadOnlyProgressionTracker> OnEnded { get; } = new();
 
     public float Progression { get; private set; } = 0f;
     public string Status { get; private set; } = "Default";
@@ -19,7 +19,7 @@ public class ProgressionTracker : IProgressionTracker
         Progression = progression.Clamp(Progression, 1f);
         Status = status;
 
-        OnUpdated?.Invoke(this, previousProgression, previousStatus);
+        OnUpdated?.Invoke(this, new(previousProgression, previousStatus));
 
         if (progression >= 1f)
             OnEnded?.Invoke(this);
@@ -30,7 +30,7 @@ public class ProgressionTracker : IProgressionTracker
         Progression = 0f;
         Status = "Default";
 
-        OnUpdated = null;
-        OnEnded = null;
+        OnUpdated.Clear();
+        OnEnded.Clear();
     }
 }