Merge branch 'patch-3'

Author: Extrys

Documentation/Images/ShieldLogos/extenject.svg

@@ -11,6 +11,7 @@
     * <a href="#signalbusinstaller">SignalBusInstaller</a>
     * <a href="#when-to-use-signals">When To Use Signals</a>
 * Advanced
+    * <a href="#abstract-signals">Abstract Signals</a>
     * <a href="#use-with-subcontainers">Signals With Subcontainers</a>
     * <a href="#async-signals">Asynchronous Signals</a>
     * <a href="#settings">Signal Settings</a>
@@ -479,6 +480,152 @@ These are just rules of thumb, but useful to keep in mind when using signals.  T
 
 When event driven program is abused, it is possible to find yourself in "callback hell" where events are triggering other events etc. and which make the entire system impossible to understand.  So signals in general should be used with caution.  Personally I like to use signals for high level game-wide events and then use other forms of communication (unirx streams, c# events, direct method calls, interfaces) for most other things.
 
+## <a id="abstract-signals"></a>Abstract Signals
+
+One of the problems of the signals is that when you subscribe to their types
+you are coupling your concrete signal types to the subscribers
+
+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``
+you are begining to get something like this...
+```csharp
+public class Example
+{
+   SignalBus signalBus;
+   public Example(Signalbus signalBus) => this.signalBus = signalBus;
+   
+   public void CheckpointReached() => signalBus.Fire<SignalCheckpointReached>();
+   
+   public void CompleteLevel() => signalBus.Fire<SignalLevelCompleted>();
+}
+
+public class SaveGameSystem
+{
+   public SaveGameSystem(SignalBus signalBus)
+   {
+      signalBus.Subscribe<SignalCheckpointReached>(x => SaveGame());
+      signalBus.Subscribe<SignalLevelCompleted>(x => SaveGame());
+   }
+   
+   void SaveGame() { /*Saves the game*/ }
+}
+
+//in your installer
+Container.DeclareSignal<SignalLevelCompleted>();
+Container.DeclareSignal<SignalCheckpointReached>();
+
+//your signal types
+public struct SignalCheckpointReached{}
+public struct SignalLevelCompleted{}
+```
+
+And then you realize you are coupling the types``signalLevelCompleted`` and ``SignalCheckpointReached``to ``SaveGameSystem``. 
+``SaveGameSystem`` shouldn't know about those "non related with saving" events...
+
+So let's give the power of interfaces to signals!
+So i have the ``SignalCheckpointReached`` and ``SignalLevelCompleted`` both implementing **``ISignalGameSaver``**
+and my ``SaveGameSystem`` just Subscribes to **``ISignalGameSaver``** for saving the game
+So when i fire any of those signals the ``SaveGameSystem`` saves the game.
+Then you have something like this...
+```csharp
+public class Example
+{
+   SignalBus signalBus;
+   public Example(Signalbus signalBus) => this.signalBus = signalBus;
+   
+   public void CheckpointReached() => signalBus.AbstractFire<SignalCheckpointReached>();
+   
+   public void CompleteLevel() => signalBus.AbstractFire<SignalLevelCompleted>();
+}
+
+public class SaveGameSystem
+{
+   public SaveGameSystem(SignalBus signalBus)
+   {
+      signalBus.Subscribe<ISignalGameSaver>(x => SaveGame());
+   }
+   
+   void SaveGame() { /*Saves the game*/ }
+}
+
+//in your installer
+Container.DeclareSignalWithInterfaces<SignalLevelCompleted>();
+Container.DeclareSignalWithInterfaces<SignalCheckpointReached>();
+
+//your signal types
+public struct SignalCheckpointReached : ISignalGameSaver{}
+public struct SignalLevelCompleted : ISignalGameSaver{}
+
+public interface ISignalGameSaver{}
+```
+
+Now your ``SaveGameSystem`` doesnt knows about CheckPoints nor Level events, and just reacts to signals that save the game.
+The main difference is in the Signal declaration and Firing
+ - ``DeclareSignalWithInterfaces`` works like ``DeclareSignal`` but it declares the interfaces too.
+ - ``AbstractFire`` is the same that ``Fire`` but it fires the interfacesjust if you have Declared the signal with interfaces 
+ otherwise it will throw an exception.
+
+Ok, let's show even more power.
+Now i create another signal for the WorldDestroyed Achievement "SignalWorldDestroyed"
+But i also want my SoundSystem to play sounds when i reach a checkpoint and/or unlock an Achievement
+So the code could look like this.
+```csharp
+public class Example
+{
+   SignalBus signalBus;
+   public Example(Signalbus signalBus) => this.signalBus = signalBus;
+   
+   public void CheckpointReached() => signalBus.AbstractFire<SignalCheckpointReached>();
+   
+   public void DestroyWorld() => signalBus.AbstractFire<SignalWorldDestroyed>();
+}
+
+public class SoundSystem
+{
+   public SoundSystem(SignalBus signalBus)
+   {
+      signalBus.Subscribe<ISignalSoundPlayer>(x => PlaySound(x.soundId));
+   }
+   
+   void PlaySound(int soundId) { /*Plays the sound with the given id*/ }
+}
+
+public class AchievementSystem
+{
+   public AchievementSystem(SignalBus signalBus)
+   {
+      signalBus.Subscribe<ISignalAchievementUnlocker>(x => UnlockAchievement(x.achievementKey));
+   }
+   
+   void UnlockAchievement(string key) { /*Unlocks the achievement with the given key*/ }
+}
+
+//in your installer
+Container.DeclareSignalWithInterfaces<SignalCheckpointReached>();
+Container.DeclareSignalWithInterfaces<SignalWorldDestroyed>();
+
+//your signal types
+public struct SignalCheckpointReached : ISignalGameSaver, ISignalSoundPlayer
+{ 
+   public int SoundId { get => 2} //or configured in a scriptable with constants instead of hardcoded
+}
+public struct SignalWorldDestroyed : ISignalAchievementUnlocker, ISignalSoundPlayer
+{
+   public int SoundId { get => 4}
+   public string AchievementKey { get => "WORLD_DESTROYED"}
+}
+
+//Your signal interfaces
+public interface ISignalGameSaver{}
+public interface ISignalSoundPlayer{ int SoundId {get;}}
+public interface ISignalAchievementUnlocker{ string AchievementKey {get;}}
+```
+
+It offers a lot of modularity and abstraction for signals,
+you fire a concrete signal telling what you did and give them functionality trough Interface implementations
+
 ## <a id="use-with-subcontainers"></a>Signals With Subcontainers
 
 Signals are only visible at the container level where they are declared and below.  For example, you might use Unity's multi-scene support and split up your game into a GUI scene and an Environment scene.  In the GUI scene you might fire a signal indicating that the GUI popup overlay has been opened/closed, so that the Environment scene can pause/resume activity.  One way of achieving this would be to declare a signal in a ProjectContext installer (or a shared <a href="../README.md#scene-parenting">scene parent</a>), then subscribe to it in the Environment scene, and then fire it from the GUI scene.

Documentation/Signals.md

@@ -30,22 +30,20 @@ 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 DeclareSignalIdRequireHandlerAsyncTickPriorityCopyBinder DeclareSignalWithInterfaces<TSignal>(this DiContainer container)
+        {
+            Type type = typeof(TSignal);
+
+            var declaration = container.DeclareSignal(type);
+
+            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)

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

@@ -41,6 +41,8 @@ public IObservable<object> Stream
         }
 #endif
 
+		public List<SignalSubscription> Subscriptions => _subscriptions;
+
         public int TickPriority
         {
             get; private set;

UnityProject/Assets/Plugins/Zenject/OptionalExtras/Signals/Internal/SignalDeclaration.cs

@@ -11,7 +11,7 @@ namespace Zenject
     public class SignalBus : ILateDisposable
     {
         readonly SignalSubscription.Pool _subscriptionPool;
-        readonly Dictionary<BindingId, SignalDeclaration> _localDeclarationMap;
+        readonly Dictionary<BindingId, SignalDeclaration> _localDeclarationMap = new Dictionary<BindingId, SignalDeclaration>();
         readonly SignalBus _parentBus;
         readonly Dictionary<SignalSubscriptionId, SignalSubscription> _subscriptionMap = new Dictionary<SignalSubscriptionId, SignalSubscription>();
         readonly ZenjectSettings.SignalSettings _settings;
@@ -35,7 +35,14 @@ public SignalBus(
             _signalDeclarationFactory = signalDeclarationFactory;
             _container = container;
 
-            _localDeclarationMap = signalDeclarations.ToDictionary(x => x.BindingId, x => x);
+           signalDeclarations.ForEach(x =>
+			{
+				if (!_localDeclarationMap.ContainsKey(x.BindingId))
+				{
+					_localDeclarationMap.Add(x.BindingId, x);
+				}
+				else _localDeclarationMap[x.BindingId].Subscriptions.AllocFreeAddRange(x.Subscriptions);
+			});
             _parentBus = parentBus;
         }
 
@@ -50,43 +57,22 @@ public int NumSubscribers
         }
 
 
-        //AbstractFire Works like a normal Fire but it fires the interface types of the signal too
+        //Fires Signals with their interfaces
         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);
-            }
-        }
-
+			Type signalType = typeof(TSignal);
+            InternalFire(signalType, signal, identifier, true);
 
+            Type[] interfaces = signalType.GetInterfaces();
+            int numOfInterfaces = interfaces.Length;
+            for (int i = 0; i < numOfInterfaces; i++)
+            {
+                InternalFire(interfaces[i], signal, identifier, true);
+            }
+		}
 
         public void LateDispose()
         {
@@ -232,7 +218,7 @@ public IObservable<TSignal> GetStream<TSignal>()
 
         public IObservable<object> GetStreamId(Type signalType, object identifier)
         {
-            return GetDeclaration(signalType, identifier, true).Stream;
+            return GetDeclaration(new BindingId(signalType, identifier)).Stream;
         }
 
         public IObservable<object> GetStream(Type signalType)