namespace DI {
 
    internal class InjectionBinder {
        public Type Abstract { get; set; }
        public Type Concrete { get; set; }
        public object[] CtorArgs { get; set; }
    }
 
    /// <summary>
    /// A lightweight dependency injection tool that supports constructor injection and HttpContext.Session caching.
    /// </summary>
    public static class Injector {
 
        private const string SessionBindingKey = "__InjectorBindings__";
        private const string SessionCacheKey = "__InjectorCache__";
 
        private static List<InjectionBinder> _bindings {
            get {
                if (HttpContext.Current.Session[SessionBindingKey] == null)
                    HttpContext.Current.Session[SessionBindingKey] = new List<InjectionBinder>();
                return (List<InjectionBinder>)HttpContext.Current.Session[SessionBindingKey];
            }
            set { HttpContext.Current.Session[SessionBindingKey] = value; }
        }
 
        private static List<KeyValuePair<Type, object>> _cache {
            get {
                if (HttpContext.Current.Session[SessionCacheKey] == null)
                    HttpContext.Current.Session[SessionCacheKey] = new List<KeyValuePair<Type, object>>();
                return (List<KeyValuePair<Type, object>>)HttpContext.Current.Session[SessionCacheKey];
            }
            set { HttpContext.Current.Session[SessionCacheKey] = value; }
        }
 
        /// <summary>
        /// Returns a concrete instance of the specified abstract type using the provided bindings and 
        /// attempts to satisfy that type's constructor arguments.
        /// </summary>
        /// <param name="abstractType">The abstract type of the object to initialize.</param>
        /// <returns></returns>
        public static object GetInstance(Type abstractType) {
 
            // Return the item from the cache if it's in there
            var cache = _cache.ToDictionary(o => o.Key, o => o.Value);
            if (cache.ContainsKey(abstractType))
                return cache[abstractType];
 
            // If the type is in the bindings, return the concrete
            var foundBinding = _bindings.Find(b => b.Abstract == abstractType);
            if (foundBinding != null)
                return Activator.CreateInstance(foundBinding.Concrete, foundBinding.CtorArgs);
 
            object obj = null;
            var ctors = abstractType.GetConstructors().ToList();
 
            // If the type has no constructor, then just create one
            if (ctors.Count == 0)
                return Activator.CreateInstance(abstractType);
 
            // If there are constructors, find one which takes arguments of the types we have binders for
            ctors.ForEach(c => {
                var prms = c.GetParameters().ToList();
                var args = new List<object>();
                var haveBindings = true;
                prms.ForEach(p => {
                    var binding = _bindings.Find(b => b.Abstract == p.ParameterType);
                    if (binding == null) { haveBindings = false; }
                    else { args.Add(Activator.CreateInstance(binding.Concrete, binding.CtorArgs)); }
                });
                if (haveBindings) { obj = Activator.CreateInstance(abstractType, args.ToArray()); }
            });
 
            return obj;
        }
 
        /// <summary>
        /// Returns a concrete instance of the specified abstract type using the provided bindings and 
        /// attempts to satisfy that type's constructor arguments.
        /// </summary>
        /// <typeparam name="TAbstract">The abstract type of the object to initialize.</typeparam>
        /// <returns></returns>
        public static TAbstract GetInstance<TAbstract>() where TAbstract : class {
            return GetInstance(typeof (TAbstract)) as TAbstract;
        }
 
        /// <summary>
        /// Creates a binding rule between an abstract type and a concrete type.
        /// </summary>
        /// <typeparam name="TAbstract">The abstract type for the binding.</typeparam>
        /// <typeparam name="TConcrete">The concrete type for the binding</typeparam>
        /// <param name="ctorArgs">The list of constructor arguments to use when initializing the instance of the concrete type.</param>
        public static void Bind<TAbstract, TConcrete>(object[] ctorArgs) {
            var binding = _bindings.Find(b => b.Abstract == typeof(TAbstract));
            if (binding != null) {
                binding.Concrete = typeof(TConcrete);
                binding.CtorArgs = ctorArgs;
            } else {
                _bindings.Add(new InjectionBinder {
                    Abstract = typeof(TAbstract),
                    Concrete = typeof(TConcrete),
                    CtorArgs = ctorArgs
                });
            }
        }
 
        /// <summary>
        /// Clears all Injector binding rules and empties the internal cache.
        /// </summary>
        public static void Kill() {
            HttpContext.Current.Session[SessionBindingKey] = null;
            HttpContext.Current.Session[SessionCacheKey] = null;
        }
    }
}

private static void BindInjectionContainer() {
    Injector.Kill(); // Clears out previously created bindings and empties the cache
 
    var currentClient = new Client(); // Doesn't matter...just an example
    var currentUser = new User();
    var currentCulture = "en-US";
 
    Injector.Bind<IClientRepository, ClientRepository>(new object[] { currentClient, currentCulture });
    Injector.Bind<IUserRepository, UserRepository>(new object[] { currentClient, currentCulture, currentUser });
    Injector.Bind<ISecurityRepository, SecurityRepository>(new object[] {});
}

var secRepo = Injector.GetInstance<ISecurityRepository>();