Merge pull request #34 from /issues/31

Issues/33 Multiple AddTo not works well

Assets/Unidux/UniduxSubscriber.cs

@@ -1,20 +1,23 @@
-using System;
-using UnityEngine;
-
-namespace Unidux
+namespace Unidux
 {
     public class UniduxSubscriber : UniduxSubscriberBase
     {
         void OnEnable()
         {
-            this._reduceSubscriber(true);
-            this._renderSubscriber(true);
+            CallReducers(true);
+            CallRenders(true);
         }
 
         void OnDisable()
         {
-            this._reduceSubscriber(false);
-            this._renderSubscriber(false);
+            CallReducers(false);
+            CallRenders(false);
+        }
+
+        void OnDestroy()
+        {
+            DisposeReducers();
+            DisposeRenders();
         }
     }
 }

Assets/Unidux/UniduxSubscriberBase.cs

@@ -1,43 +1,94 @@
 using System;
+using System.Collections.Generic;
 using UnityEngine;
 
 namespace Unidux
 {
     public class UniduxSubscriberBase : MonoBehaviour, IUniduxSubscriber
     {
-        protected Action<bool> _renderSubscriber = (enable) => { };
-        protected Action<bool> _reduceSubscriber = (enable) => { };
+        private readonly Dictionary<int, Action<bool>> _renderSubscriberMap = new Dictionary<int, Action<bool>>();
+        private readonly Dictionary<int, Action<bool>> _reduceSubscriberMap = new Dictionary<int, Action<bool>>();
 
         public void AddRenderTo<S>(Store<S> store, Render<S> render) where S : StateBase, new()
         {
-            _renderSubscriber = (enable) =>
+            Action<bool> renderSubscriber = null;
+            int key = render.GetHashCode();
+
+            if (_renderSubscriberMap.ContainsKey(key))
             {
-                if (enable)
-                {
-                    store.RenderEvent += render;
-                }
-                else
+                renderSubscriber = _renderSubscriberMap[key];
+            }
+            else
+            {
+                renderSubscriber = (enable) =>
                 {
-                    store.RenderEvent -= render;
-                }
-            };
-            _renderSubscriber(true);
+                    if (enable)
+                    {
+                        store.RenderEvent += render;
+                    }
+                    else
+                    {
+                        store.RenderEvent -= render;
+                    }
+                };
+            }
+            renderSubscriber(true);
+
+            _renderSubscriberMap[key] = renderSubscriber;
         }
 
-        public void AddReducerTo<S, A>(Store<S> store, Reducer<S, A> render) where S : StateBase, new()
+        public void AddReducerTo<S, A>(Store<S> store, Reducer<S, A> reducer) where S : StateBase, new()
         {
-            _reduceSubscriber = (enable) =>
+            Action<bool> reduceSubscriber = null;
+            int key = reducer.GetHashCode();
+
+            if (_reduceSubscriberMap.ContainsKey(key))
             {
-                if (enable)
-                {
-                    store.AddReducer(render);
-                }
-                else
+                reduceSubscriber = _reduceSubscriberMap[key];
+            }
+            else
+            {
+                reduceSubscriber = (enable) =>
                 {
-                    store.RemoveReducer(render);
-                }
-            };
-            _reduceSubscriber(true);
+                    if (enable)
+                    {
+                        store.AddReducer(reducer);
+                    }
+                    else
+                    {
+                        store.RemoveReducer(reducer);
+                    }
+                };
+            }
+            reduceSubscriber(true);
+
+            _reduceSubscriberMap[key] = reduceSubscriber;
+        }
+
+        protected void CallRenders(bool subscribe)
+        {
+            foreach (var caller in _renderSubscriberMap.Values)
+            {
+                caller(subscribe);
+            }
+        }
+
+        protected void CallReducers(bool subscribe)
+        {
+            foreach (var caller in _reduceSubscriberMap.Values)
+            {
+                caller(subscribe);
+            }
+        }
+
+        protected void DisposeRenders()
+        {
+            _renderSubscriberMap.Clear();
+        }
+
+        protected void DisposeReducers()
+        {
+            _reduceSubscriberMap.Clear();
         }
     }
 }

Assets/Unidux/UniduxSustainSubscriber.cs

@@ -4,16 +4,16 @@ public class UniduxSustainSubscriber : UniduxSubscriberBase
     {
         void Start()
         {
-            _renderSubscriber(true);
-            _reduceSubscriber(true);
+            CallReducers(true);
+            CallRenders(true);
         }
 
         void OnDestroy()
         {
-            _renderSubscriber(false);
-            _reduceSubscriber(false);
-            _renderSubscriber = null;
-            _reduceSubscriber = null;
+            CallReducers(false);
+            CallRenders(false);
+            DisposeReducers();
+            DisposeRenders();
         }
     }
 }

Assets/UniduxExample/Counter/Scripts/Unidux.cs

@@ -2,13 +2,18 @@
 {
     public class Unidux : SingletonMonoBehaviour<Unidux>
     {
-        public Store<State> Store { get; private set; }
-
-        protected override void Awake()
+        private Store<State> _store;
+        public Store<State> Store
         {
-            base.Awake();
-            this.Store = new Store<State>();
-            this.Store.AddReducer<CountAction>(CountReducer.Reduce);
+            get
+            {
+                if (null == _store)
+                {
+                    _store = new Store<State>();
+                    _store.AddReducer<CountAction>(CountReducer.Reduce);
+                }
+                return _store;
+            }
         }
 
         void Update()

Assets/UniduxExample/List/Scripts/Unidux.cs

@@ -2,13 +2,20 @@
 {
     public class Unidux : SingletonMonoBehaviour<Unidux>
     {
-        public Store<State> Store { get; private set; }
+        private Store<State> _store;
 
-        protected override void Awake()
+        public Store<State> Store
         {
-            base.Awake();
-            this.Store = new Store<State>();
-            this.Store.AddReducer<ListAddAction>(ListReducer.Reduce);
+            get
+            {
+                if (null == _store)
+                {
+                    _store = new Store<State>();
+                    _store.AddReducer<ListAddAction>(ListReducer.Reduce);
+                }
+
+                return _store;
+            }
         }
 
         void Update()