Revert "feat: Add priority for event handlers to Exiled Events (#423)"

This reverts commit eb6ac98.

Author: louis1706

.gitignore

@@ -376,7 +376,4 @@ _site/
 JSON/
 
 # Mac DS_Store
-.DS_Store
-
-# Code Rush
-/EXILED/.cr/*
+.DS_Store

EXILED/Exiled.Events/Features/Event.cs

@@ -30,20 +30,8 @@ namespace Exiled.Events.Features
     /// </summary>
     public class Event : IExiledEvent
     {
-        private record Registration(CustomEventHandler handler, int priority);
-
-        private record AsyncRegistration(CustomAsyncEventHandler handler, int priority);
-
         private static readonly List<Event> EventsValue = new();
 
-        private static readonly IComparer<Registration> RegisterComparable = Comparer<Registration>.Create((x, y) => y.priority - x.priority);
-
-        private static readonly IComparer<AsyncRegistration> AsyncRegisterComparable = Comparer<AsyncRegistration>.Create((x, y) => y.priority - x.priority);
-
-        private readonly List<Registration> innerEvent = new();
-
-        private readonly List<AsyncRegistration> innerAsyncEvent = new();
-
         private bool patched;
 
         /// <summary>
@@ -54,6 +42,10 @@ public Event()
             EventsValue.Add(this);
         }
 
+        private event CustomEventHandler InnerEvent;
+
+        private event CustomAsyncEventHandler InnerAsyncEvent;
+
         /// <summary>
         /// Gets a <see cref="IReadOnlyList{T}"/> of <see cref="Event{T}"/> which contains all the <see cref="Event{T}"/> instances.
         /// </summary>
@@ -112,14 +104,6 @@ public Event()
         /// </summary>
         /// <param name="handler">The handler to add.</param>
         public void Subscribe(CustomEventHandler handler)
-            => Subscribe(handler, 0);
-
-        /// <summary>
-        /// Subscribes a target <see cref="CustomEventHandler"/> to the inner event if the conditional is true.
-        /// </summary>
-        /// <param name="handler">The handler to add.</param>
-        /// <param name="priority">The highest priority is the first called, the lowest the last.</param>
-        public void Subscribe(CustomEventHandler handler, int priority)
         {
             Log.Assert(Events.Instance is not null, $"{nameof(Events.Instance)} is null, please ensure you have exiled_events enabled!");
 
@@ -129,36 +113,14 @@ public void Subscribe(CustomEventHandler handler, int priority)
                 patched = true;
             }
 
-            if (handler == null)
-                return;
-
-            Registration registration = new Registration(handler, priority);
-            int index = innerEvent.BinarySearch(registration, RegisterComparable);
-            if (index < 0)
-            {
-                innerEvent.Insert(~index, registration);
-            }
-            else
-            {
-                while (index < innerEvent.Count && innerEvent[index].priority == priority)
-                    index++;
-                innerEvent.Insert(index, registration);
-            }
+            InnerEvent += handler;
         }
 
         /// <summary>
         /// Subscribes a target <see cref="CustomAsyncEventHandler"/> to the inner event if the conditional is true.
         /// </summary>
         /// <param name="handler">The handler to add.</param>
         public void Subscribe(CustomAsyncEventHandler handler)
-            => Subscribe(handler, 0);
-
-        /// <summary>
-        /// Subscribes a target <see cref="CustomAsyncEventHandler"/> to the inner event if the conditional is true.
-        /// </summary>
-        /// <param name="handler">The handler to add.</param>
-        /// <param name="priority">The highest priority is the first called, the lowest the last.</param>
-        public void Subscribe(CustomAsyncEventHandler handler, int priority)
         {
             Log.Assert(Events.Instance is not null, $"{nameof(Events.Instance)} is null, please ensure you have exiled_events enabled!");
 
@@ -168,21 +130,7 @@ public void Subscribe(CustomAsyncEventHandler handler, int priority)
                 patched = true;
             }
 
-            if (handler == null)
-                return;
-
-            AsyncRegistration registration = new AsyncRegistration(handler, 0);
-            int index = innerAsyncEvent.BinarySearch(registration, AsyncRegisterComparable);
-            if (index < 0)
-            {
-                innerAsyncEvent.Insert(~index, registration);
-            }
-            else
-            {
-                while (index < innerAsyncEvent.Count && innerAsyncEvent[index].priority == priority)
-                    index++;
-                innerAsyncEvent.Insert(index, registration);
-            }
+            InnerAsyncEvent += handler;
         }
 
         /// <summary>
@@ -191,9 +139,7 @@ public void Subscribe(CustomAsyncEventHandler handler, int priority)
         /// <param name="handler">The handler to add.</param>
         public void Unsubscribe(CustomEventHandler handler)
         {
-            int index = innerEvent.FindIndex(p => p.handler == handler);
-            if (index != -1)
-                innerEvent.RemoveAt(index);
+            InnerEvent -= handler;
         }
 
         /// <summary>
@@ -202,88 +148,52 @@ public void Unsubscribe(CustomEventHandler handler)
         /// <param name="handler">The handler to add.</param>
         public void Unsubscribe(CustomAsyncEventHandler handler)
         {
-            int index = innerAsyncEvent.FindIndex(p => p.handler == handler);
-            if (index != -1)
-                innerAsyncEvent.RemoveAt(index);
+            InnerAsyncEvent -= handler;
         }
 
         /// <summary>
         /// Executes all <see cref="CustomEventHandler"/> listeners safely.
         /// </summary>
         public void InvokeSafely()
         {
-            BlendedInvoke();
-        }
-
-        /// <inheritdoc cref="InvokeSafely"/>
-        internal void BlendedInvoke()
-        {
-            Registration[] innerEvent = this.innerEvent.ToArray();
-            AsyncRegistration[] innerAsyncEvent = this.innerAsyncEvent.ToArray();
-            int count = innerEvent.Length + innerAsyncEvent.Length;
-            int eventIndex = 0, asyncEventIndex = 0;
-
-            for (int i = 0; i < count; i++)
-            {
-                if (eventIndex < innerEvent.Length && (asyncEventIndex >= innerAsyncEvent.Length || innerEvent[eventIndex].priority >= innerAsyncEvent[asyncEventIndex].priority))
-                {
-                    try
-                    {
-                        innerEvent[eventIndex].handler();
-                    }
-                    catch (Exception ex)
-                    {
-                        Log.Error($"Method \"{innerEvent[eventIndex].handler.Method.Name}\" of the class \"{innerEvent[eventIndex].handler.Method.ReflectedType.FullName}\" caused an exception when handling the event \"{GetType().FullName}\"\n{ex}");
-                    }
-
-                    eventIndex++;
-                }
-                else
-                {
-                    try
-                    {
-                        Timing.RunCoroutine(innerAsyncEvent[asyncEventIndex].handler());
-                    }
-                    catch (Exception ex)
-                    {
-                        Log.Error($"Method \"{innerAsyncEvent[asyncEventIndex].handler.Method.Name}\" of the class \"{innerAsyncEvent[asyncEventIndex].handler.Method.ReflectedType.FullName}\" caused an exception when handling the event \"{GetType().FullName}\"\n{ex}");
-                    }
-
-                    asyncEventIndex++;
-                }
-            }
+            InvokeNormal();
+            InvokeAsync();
         }
 
         /// <inheritdoc cref="InvokeSafely"/>
         internal void InvokeNormal()
         {
-            Registration[] innerEvent = this.innerEvent.ToArray();
-            foreach (Registration registration in innerEvent)
+            if (InnerEvent is null)
+                return;
+
+            foreach (CustomEventHandler handler in InnerEvent.GetInvocationList().Cast<CustomEventHandler>())
             {
                 try
                 {
-                    registration.handler();
+                    handler();
                 }
                 catch (Exception ex)
                 {
-                    Log.Error($"Method \"{registration.handler.Method.Name}\" of the class \"{registration.handler.Method.ReflectedType.FullName}\" caused an exception when handling the event \"{GetType().FullName}\"\n{ex}");
+                    Log.Error($"Method \"{handler.Method.Name}\" of the class \"{handler.Method.ReflectedType.FullName}\" caused an exception when handling the event \"{GetType().FullName}\"\n{ex}");
                 }
             }
         }
 
         /// <inheritdoc cref="InvokeSafely"/>
         internal void InvokeAsync()
         {
-            AsyncRegistration[] innerAsyncEvent = this.innerAsyncEvent.ToArray();
-            foreach (AsyncRegistration registration in innerAsyncEvent)
+            if (InnerAsyncEvent is null)
+                return;
+
+            foreach (CustomAsyncEventHandler handler in InnerAsyncEvent.GetInvocationList().Cast<CustomAsyncEventHandler>())
             {
                 try
                 {
-                    Timing.RunCoroutine(registration.handler());
+                    Timing.RunCoroutine(handler());
                 }
                 catch (Exception ex)
                 {
-                    Log.Error($"Method \"{registration.handler.Method.Name}\" of the class \"{registration.handler.Method.ReflectedType.FullName}\" caused an exception when handling the event \"{GetType().FullName}\"\n{ex}");
+                    Log.Error($"Method \"{handler.Method.Name}\" of the class \"{handler.Method.ReflectedType.FullName}\" caused an exception when handling the event \"{GetType().FullName}\"\n{ex}");
                 }
             }
         }