Interface compatibility for signals

Normally you can not declare concrete interfaces
and then subscribe to their interface types
and you realice you are coupling your concrete signal types to the receivers
for example.
Lets say I have a player and i want to save the game when i finish a level 
Ok easy I create "
signalLevelCompleted" and then I subscribe it to my "SaveGameSystem"

then I also want to save when i reach a checkpoint
Again i create "SignalCheckpointReached"
and then I subscribe it to my "SaveGameSystem"

And then you realize you are coupling the types
"signalLevelCompleted" and "SignalCheckpointReached" to your "SaveGameSystem"

ohhh its not too good...
but lets give the power of the interfaces to the signals

So i have the  SignalCheckPoint reached
and SignalLevelCompleted 
Both implements ISignalGameSaver

My GameSaverSystem just Subscribes to ISignalSaveGame for saving the game
So when i shot any of that signals i automatically save the game

and if for example i create another signal for Achievements "SignalAchievementCompleted"
I just have to implement the interface to it so it saves the game automatically

It offers a lot of modularity and abstractions to signals
Since you are firing a concrete signal with the action you are doing
And giving them functionality trough Interface implementations

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)