Merge branch 'SignalInterfaceCompatibility'

Author: Extrys

UnityProject/Assets/Plugins/Zenject/OptionalExtras/Signals/Internal/Binders/SignalExtensions.cs

@@ -30,6 +30,24 @@ public static DeclareSignalIdRequireHandlerAsyncTickPriorityCopyBinder DeclareSi
             return container.DeclareSignal(typeof(TSignal));
         }
 
+        //If you declare a concrete signal type with their interfaces you can do abstract Firing to get their non concrete subscriptions
+        public static DeclareSignalIdRequireHandlerAsyncTickPriorityCopyBinder DeclareSignalWithInterfaces<TSignal>(this DiContainer container)
+        {
+            Type type = typeof(TSignal);
+
+            var declaration = container.DeclareSignal(type);
+
+            //Automatic interface declaration
+            Type[] interfaces = type.GetInterfaces();
+            int numOfInterfaces = interfaces.Length;
+            for (int i = 0; i < numOfInterfaces; i++)
+            {
+                container.DeclareSignal(interfaces[i]);
+            }
+
+            return declaration;
+        }
+
         public static BindSignalIdToBinder<TSignal> BindSignal<TSignal>(this DiContainer container)
         {
             var signalBindInfo = new SignalBindingBindInfo(typeof(TSignal));

UnityProject/Assets/Plugins/Zenject/OptionalExtras/Signals/Main/SignalBus.cs

@@ -49,6 +49,45 @@ public int NumSubscribers
             get { return _subscriptionMap.Count; }
         }
 
+
+        //AbstractFire Works like a normal Fire but it fires the interface types of the signal too
+        public void AbstractFire<TSignal>() where TSignal : new() => AbstractFire(new TSignal());
+		public void AbstractFire<TSignal>(TSignal signal) => AbstractFireId(null, signal);
+		public void AbstractFireId<TSignal>(object identifier, TSignal signal)
+		{
+			// Do this before creating the signal so that it throws if the signal was not declared
+			Type tt = typeof(TSignal);
+			var declaration = GetDeclaration(tt, identifier, true);
+			declaration.Fire(signal);
+
+            //Everything is fired like a normal signal and then this method Fires the signal with the interface types
+            //Its async because its faster and doesn't blocks the main thread when you fire signals
+            //Tested with a loop of 1 million iteration and this is the faster way of getting the interfaces fast
+			FireSignalGetDeclarationForInterfacesAsync(identifier, signal, tt);
+		}
+
+        //Fire and forget methof for the task
+		public async void FireSignalGetDeclarationForInterfacesAsync<TSignal>(object identifier, TSignal signal, Type type)
+		{
+			await Task.Run(() => FireSignalGetDeclarationForInterfacesTask(identifier, signal, type));
+		}
+        public async Task FireSignalGetDeclarationForInterfacesTask<TSignal>(object identifier, TSignal signal, Type type)
+        {
+            //The asynchronous iteration for reflection
+            Type[] interfaces = type.GetInterfaces();
+            int numOfInterfaces = interfaces.Length;
+            for (int i = 0; i < numOfInterfaces; i++)
+            {
+                //To make this work you should also declare the signal's interfaces, but they are automatically declared
+                //if you do "DeclareSignalWithInterfaces<TSignal>()" in the container 
+                //Go to SignalExtensions.cs for more info
+                var declaration = GetDeclaration(interfaces[i], identifier, true);
+                declaration.Fire(signal);
+            }
+        }
+
+
+
         public void LateDispose()
         {
             if (_settings.RequireStrictUnsubscribe)