Added caching to Injector. When attempting to inject into a type after the first time it will use cached values for the properties and fields instead of doing reflection every time.

Added some nice helper functions to Binding:

Access and modify binds quicker with [] operator overload
Clear all binds with .Clear()
Clear specific binds with .Clear(T)
Get an array of all bindings with .ToArray()
Get number of bindings with .Count

Modified Scene/SceneObjectData and Factory to use Bindings instead of a Dictionary

Author: cleavetv

Assets/CleaveFramework/Binding/Binding.cs

@@ -103,5 +103,50 @@ public bool IsBound(T type)
             return Bindings.ContainsKey(type);
         }
 
+        /// <summary>
+        /// removes all bindings from the library
+        /// </summary>
+        public void Clear()
+        {
+            Bindings.Clear();
+        }
+
+        /// <summary>
+        /// removes binding of type from the library
+        /// </summary>
+        /// <param name="type"></param>
+        public void Clear(T type)
+        {
+            Bindings.Remove(type);
+        }
+
+        /// <summary>
+        /// return the bindings library as an associative array
+        /// </summary>
+        /// <returns></returns>
+        public KeyValuePair<T, V>[] ToArray()
+        {
+            return Bindings.ToArray();
+        }
+
+        /// <summary>
+        /// return the number of total bindings in the library
+        /// </summary>
+        public int Count
+        {
+            get { return Bindings.Count; }
+        }
+
+        /// <summary>
+        /// [] operator overload
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public V this[T type]
+        {
+            get { return Resolve(type); }
+            set { Bind(type, value);  }
+        }
     }
+
 }

Assets/CleaveFramework/Core/Framework.cs

@@ -45,7 +45,7 @@ public static string TransitionScene
         void Awake()
         {
             CDebug.DisplayMethod = CDebug.ConsoleLogMethod.Selected;
-            CDebug.LogThis(typeof(Injector));
+            //CDebug.LogThis(typeof(Injector));
 
             if (Instance != this && Instance != null)
             {

Assets/CleaveFramework/Dependency Inject/Injector.cs

@@ -12,6 +12,8 @@ You may obtain a copy of the License at
    See the License for the specific language governing permissions and
    limitations under the License. */
 using System;
+using System.Collections;
+using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using CleaveFramework.Binding;
@@ -55,9 +57,12 @@ private enum InjectTypes
 
         private static Binding<Type, InjectTypes> _injectionTypes = new Binding<Type, InjectTypes>();
         private static Binding<Type, object> _singletons = new Binding<Type, object>();
-
         private static Binding<Type, Type> _transients = new Binding<Type, Type>(); 
 
+        private static Binding<Type, IEnumerable<FieldInfo>>  _fieldsCache = new Binding<Type, IEnumerable<FieldInfo>>();
+        private static Binding<Type, IEnumerable<PropertyInfo>> _propertyCache = new Binding<Type, IEnumerable<PropertyInfo>>();
+        private static Binding<Type, IEnumerable<MemberInfo>> _memberCache = new Binding<Type, IEnumerable<MemberInfo>>();
+
         /// <summary>
         /// Add a Transient type to the Injector and map it to a specific implementation
         /// </summary>
@@ -117,11 +122,23 @@ private static object Resolve(Type t)
 
         private static void InjectProperties<T>(T obj)
         {
-            var props = typeof(T).GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(Inject)));
+            var injectingType = typeof (T);
+
+            IEnumerable<PropertyInfo> props;
+            if (_propertyCache.IsBound(injectingType))
+            {
+                props = _propertyCache.Resolve(injectingType);
+            }
+            else
+            {
+                props = injectingType.GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(Inject)));
+                _propertyCache.Bind(injectingType, props);
+            }
+            CDebug.Assert(props == null, "Injector.InjectProperties()");
+
             foreach (var cProp in props)
             {
                 if (!cProp.CanWrite) continue;
-
                 CDebug.Log("Injector.InjectProperties<" + cProp.PropertyType + "> on " + obj);
                 var instance = Resolve(cProp.PropertyType);
                 cProp.SetValue(obj, instance, null);
@@ -130,7 +147,21 @@ private static void InjectProperties<T>(T obj)
 
         private static void InjectFields<T>(T obj)
         {
-            var fields = typeof(T).GetFields().Where(prop => Attribute.IsDefined(prop, typeof(Inject)));
+
+            var injectingType = typeof(T);
+
+            IEnumerable<FieldInfo> fields;
+            if (_fieldsCache.IsBound(injectingType))
+            {
+                fields = _fieldsCache.Resolve(injectingType);
+            }
+            else
+            {
+                fields = injectingType.GetFields().Where(prop => Attribute.IsDefined(prop, typeof(Inject)));
+                _fieldsCache.Bind(injectingType, fields);
+            }
+            CDebug.Assert(fields == null, "Injector.InjectFields()");
+
             foreach (var cField in fields)
             {
                 CDebug.Log("Injector.InjectFields<" + cField.FieldType + "> on " + obj);
@@ -142,12 +173,27 @@ private static void InjectFields<T>(T obj)
         private static void InjectMonoBehaviour<T>(T obj)
         {
             var monoObj = obj as MonoBehaviour;
-            var monoFields = monoObj.GetType().GetMembers().Where(prop => Attribute.IsDefined(prop, typeof(Inject)));
-            foreach (FieldInfo monoField in monoFields)
+
+            var injectingType = monoObj.GetType();
+
+            IEnumerable<MemberInfo> members;
+            if (_memberCache.IsBound(injectingType))
             {
-                CDebug.Log("Injector.InjectMonoBehaviour<" + monoField.FieldType + "> on " + obj);
-                var instance = Resolve(monoField.FieldType);
-                monoField.SetValue(monoObj, instance);
+                members = _memberCache.Resolve(injectingType);
+            }
+            else
+            {
+                members = injectingType.GetMembers().Where(prop => Attribute.IsDefined(prop, typeof(Inject)));
+                _memberCache.Bind(injectingType, members);
+            }
+            CDebug.Assert(members == null, "Injector.InjectMonoBehaviour()");
+
+            // for some reason MonoBehaviour members need to be addressed as fields.
+            foreach (FieldInfo cField in members)
+            {
+                CDebug.Log("Injector.InjectMonoBehaviour<" + cField.FieldType + "> on " + obj);
+                var instance = Resolve(cField.FieldType);
+                cField.SetValue(monoObj, instance);
             }
         }
 

Assets/CleaveFramework/Factory/Factory.cs

@@ -12,7 +12,7 @@ You may obtain a copy of the License at
    See the License for the specific language governing permissions and
    limitations under the License. */
 using System;
-using System.Collections.Generic;
+using CleaveFramework.Binding;
 using CleaveFramework.DependencyInjection;
 using CleaveFramework.Scene;
 using CleaveFramework.Tools;
@@ -32,7 +32,7 @@ namespace CleaveFramework.Factory
     /// </summary>
     static class Factory
     {
-        static Dictionary<Type, Constructor> _constructors = new Dictionary<Type, Constructor>();
+        static Binding<Type, Constructor> _constructors = new Binding<Type,Constructor>();
 
         /// <summary>
         /// Sets a post instantiation constructor to an object type
@@ -41,13 +41,7 @@ static class Factory
         /// <param name="constructor">delegate to act as constructor</param>
         static public void SetConstructor<T>(Constructor constructor)
         {
-            // for now we are a single delegate
-            if (_constructors.ContainsKey(typeof (T)))
-            {
-                _constructors[typeof (T)] = constructor;
-                return;
-            }
-            _constructors.Add(typeof(T), constructor);
+            _constructors[typeof (T)] = constructor;
         }
 
         /// <summary>
@@ -473,7 +467,7 @@ static public object Create(Type t)
         {
             var obj = Activator.CreateInstance(t);
             obj = Injector.PerformInjections(obj);
-            if (_constructors.ContainsKey(t))
+            if (_constructors.IsBound(t))
             {
                 _constructors[t].Invoke(obj);
             }
@@ -581,12 +575,9 @@ static private object InvokeConstructor<T>(object obj, Constructor constructor)
 
         static private object InvokeDefaultConstructor<T>(object obj)
         {
-            if (_constructors.ContainsKey(typeof(T)))
-            {
-                if (_constructors[typeof(T)] != null)
-                    obj = (T)_constructors[typeof(T)].Invoke(obj);
-            }
-            return obj;
+            var objType = typeof (T);
+            if (!_constructors.IsBound(objType)) return obj;
+            return (T)_constructors[objType].Invoke(obj);
         }
 
         static private GameObject ResolveGameObject(string goName)

Assets/CleaveFramework/Scene/SceneObjectData.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using CleaveFramework.Interfaces;
 using CleaveFramework.Tools;
+using CleaveFramework.Binding;
 
 namespace CleaveFramework.Scene
 {
@@ -13,51 +14,44 @@ public sealed class SceneObjectData
         /// <summary>
         /// singleton library
         /// </summary>
-        private Dictionary<Type, object> _singletons;
+        //private Dictionary<Type, object> _singletons;
+        private Binding<Type, object> _singletons = new Binding<Type,object>();
 
         /// <summary>
         /// transient objects library
         /// </summary>
-        private Dictionary<Type, Dictionary<string, object>> _transients;
+        //private Dictionary<Type, Dictionary<string, object>> _transients;
+        private Binding<Type, Binding<string, object>> _transients = new Binding<Type, Binding<string, object>>();
 
         /// <summary>
         /// IUpdateable objects library
         /// </summary>
-        private List<IUpdateable> _updateables;
+        private List<IUpdateable> _updateables = new List<IUpdateable>();
 
         /// <summary>
         /// IInitializeable objects library
         /// </summary>
-        private List<IInitializeable> _initializeables;
+        private List<IInitializeable> _initializeables = new List<IInitializeable>();
 
         /// <summary>
         /// IConfigureable objects library
         /// </summary>
-        private List<IConfigureable> _configureables;
+        private List<IConfigureable> _configureables = new List<IConfigureable>();
 
         /// <summary>
         /// IConfigureable objects library
         /// </summary>
-        private List<IDestroyable> _destroyables;
+        private List<IDestroyable> _destroyables = new List<IDestroyable>();
 
         public bool IsObjectDataInitialized { get; private set; }
 
         public SceneObjectData()
         {
-            _singletons = new Dictionary<Type, object>();
-            _transients = new Dictionary<Type, Dictionary<string, object>>();
-            _updateables = new List<IUpdateable>();
-            _initializeables = new List<IInitializeable>();
-            _configureables = new List<IConfigureable>();
-            _destroyables = new List<IDestroyable>();
             IsObjectDataInitialized = false;
-            //CDebug.LogThis(typeof(SceneObjectData));
         }
 
         public void Destroy()
         {
-            CDebug.Log("SceneObjectData::Destroy()");
-
             foreach (var obj in _destroyables)
             {
                 obj.Destroy();
@@ -140,6 +134,16 @@ private static void ReflectInterfaces<T>(SceneObjectData instance, T obj)
             }
         }
 
+        /// <summary>
+        /// Injects an object instance into the framework singleton library
+        /// </summary>
+        /// <typeparam name="T">object type</typeparam>
+        /// <param name="obj">object instance</param>
+        public object PushSingleton<T>(T obj)
+        {
+            return PushObjectAsSingleton(obj);
+        }
+
         /// <summary>
         /// Injects an object instance into the framework singleton library
         /// </summary>
@@ -149,18 +153,7 @@ public object PushObjectAsSingleton<T>(T obj)
         {
             // reflect on the implemented interfaces
             ReflectInterfaces(this, obj);
-
-            if (!_singletons.ContainsKey(typeof(T)))
-            {
-                // insert object into the library
-                _singletons.Add(typeof(T), obj);
-            }
-            else
-            {
-                // overwrite existing object with new instance
-                _singletons[typeof(T)] = obj;
-            }
-
+            _singletons[typeof (T)] = obj;
             return obj;
         }
 
@@ -171,7 +164,18 @@ public object PushObjectAsSingleton<T>(T obj)
         /// <returns>object instance if injected, otherwise null</returns>
         public object ResolveSingleton<T>()
         {
-            return _singletons.ContainsKey(typeof(T)) ? _singletons[typeof(T)] : null;
+            return _singletons[typeof (T)];
+        }
+
+        /// <summary>
+        /// Inject an object instance into the framework transients library
+        /// </summary>
+        /// <typeparam name="T">object type</typeparam>
+        /// <param name="name">object instance name, required for lookup and must be unique per type</param>
+        /// <param name="obj">object instance</param>
+        public object PushTransient<T>(string name, T obj)
+        {
+            return PushObjectAsTransient(name, obj);
         }
 
         /// <summary>
@@ -184,20 +188,17 @@ public object PushObjectAsTransient<T>(string name, T obj)
         {
             ReflectInterfaces(this, obj);
 
-            if (!_transients.ContainsKey(typeof (T)))
-            {
-                _transients.Add(typeof(T), new Dictionary<string, object>());
-            }
-
-            if (_transients[typeof (T)].ContainsKey(name))
+            var objType = typeof (T);
+            if (!_transients.IsBound(objType))
             {
-                throw new Exception("Object instance type/name combination is not unique: " + typeof(T).ToString() + "/" + name);
+                _transients.Bind(objType, new Binding<string, object>());
             }
 
-            _transients[typeof(T)].Add(name, obj);
+            CDebug.Assert(_transients[objType].IsBound(name),
+                "Object instance type/name combination is not unique: " + objType + "/" + name);
 
+            _transients[objType][name] = obj;
             return obj;
-
         }
 
         /// <summary>
@@ -208,14 +209,8 @@ public object PushObjectAsTransient<T>(string name, T obj)
         /// <returns>object instance</returns>
         public object ResolveTransient<T>(string name)
         {
-            if (!_transients.ContainsKey(typeof (T)))
-            {
-                return null;
-            }
-            return !_transients[typeof (T)].ContainsKey(name) ? null : _transients[typeof (T)][name];
+            var objType = typeof (T);
+            return !_transients.IsBound(objType) ? null : _transients[objType][name];
         }
-
-
-
     }
 }