public object Resolve(IResolutionRoot resolutionRoot, IResolutionParameters resolutionParameters)
        {
            Type type = resolutionParameters.TypeToResolve;
            TypeInfo typeInfo = type.GetTypeInfo();

            if (typeInfo.IsGenericType)
            {
                var genericType = type.GetGenericTypeDefinition();
                if (genericType == typeof(IEnumerable<>) ||
                    genericType == typeof(ICollection<>) ||
                    genericType == typeof(IList<>) ||
                    genericType == typeof(List<>))
                {
                    return this.GetAllAsList(resolutionRoot, typeInfo.GenericTypeArguments[0], resolutionParameters);
                }
            }

            if (typeInfo.IsArray)
            {
                var argumentType = type.GetElementType();
                return this.GetAllAsArray(resolutionRoot, argumentType, resolutionParameters);
            }

            return resolutionRoot.Get(
                type,
                resolutionParameters.Constraint,
                resolutionParameters.Parameters.ToArray());
        }

        public NinjectDependencyScope(IResolutionRoot resolver)
        {
            if (resolver == null)
                throw new ArgumentNullException("resolver");

            this.resolver = resolver;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="ChildKernel"/> class.
 /// </summary>
 /// <param name="parent">The parent.</param>
 /// <param name="modules">The modules.</param>
 public ChildKernel(IResolutionRoot parent, params INinjectModule[] modules)
     : base(modules)
 {
     this.parent = parent;
     this.Components.RemoveAll<IActivationCache>();
     this.Components.Add<IActivationCache, ChildActivationCache>();
 }

 public NinjectServiceScope(
     IResolutionRoot resolver,
     IEnumerable<IParameter> inheritedParameters)
 {
     _scope = new ScopeParameter();
     inheritedParameters = inheritedParameters.AddOrReplaceScopeParameter(_scope);
     _serviceProvider = new NinjectServiceProvider(resolver, inheritedParameters.ToArray());
 }

 private static ChildKernel CreateAuthKernel(IResolutionRoot parent)
 {
     var kernel = new ChildKernel(parent, new ServerModule(), new AuthServerModule());
     kernel.Rebind<IPacketCodeTable>().To<AuthPacketCodeTableV75>().InSingletonScope();
     kernel.Rebind<IAuthenticator>().To<StubAuthenticator>().InSingletonScope();
     kernel.Rebind<IAccountProvider>().To<StubAccountProvider>().InSingletonScope();
     return kernel;
 }

        /// <summary>
        /// Initializes it all.
        /// </summary>
        public WcfBootstrapper(IEnumerable<OsWcfConfiguration> configurations, IResolutionRoot resolutionRoot, ILogger logger)
            : base(resolutionRoot, logger)
        {
            this.configurations = configurations.ToList();
            this.hosts = new List<ServiceHost>(this.configurations.Count);

            this.isDisposed = false;
        }

 public object GetAllAsArray(IResolutionRoot resolutionRoot, Type type, IResolutionParameters resolutionParameters)
 {
     var list = this.GetAllAsList(resolutionRoot, type, resolutionParameters);
     return typeof(Enumerable)
         .GetTypeInfo()
         .GetDeclaredMethod("ToArray")
         .MakeGenericMethod(type)
         .Invoke(null, new[] { list });
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ChildKernel"/> class.
        /// </summary>
        /// <param name="parent">The parent.</param>
        /// <param name="modules">The modules.</param>
        public ChildKernel(IResolutionRoot parent, params INinjectModule[] modules)
            : base(modules)
        {
            this.parent = parent;
            this.Components.RemoveAll<IActivationCache>();
            this.Components.Add<IActivationCache, ChildActivationCache>();

            this.Components.RemoveAll<IConstructorScorer>();
            this.Components.Add<IConstructorScorer, StandardConstructorScorerForChildKernel>();
        }

        public NinjectServiceScopeFactory(IContext context)
        {
            _resolver = context.Kernel.Get<IResolutionRoot>();
            _inheritedParameters = context.Parameters.Where(p => p.ShouldInherit);

            var scopeParameter = _inheritedParameters.GetScopeParameter();
            if (scopeParameter != null)
            {
                _fallbackProvider = scopeParameter.FallbackProvider;
            }
        }

        private static IContextStore GetStore(IResolutionRoot kernel)
        {
            var store = kernel.TryGet<IContextStore>();
            
            if (store == null)
            {
                throw new InvalidOperationException(
                    "There is no IContextStore implementation registered in the container.");
            }

            return store;
        }

        public SimpleBootstrapper(IResolutionRoot resolutionRoot, ILogger logger)
            : base(resolutionRoot, logger)
        {
            var nexus = new ChildKernel(this.ResolutionRoot, new NexusServerModule());

            this.account = new ChildKernel(nexus, new AccountServerModule());
            this.auth = CreateAuthKernel(nexus);
            this.world = new ChildKernel(nexus, new WorldServerModule());
            this.channel = new ChildKernel(this.world, new ServerModule(), new ChannelServerModule());

            // HACK :(
            nexus.Bind<IAccountService>().ToMethod(ctx => this.account.Get<IAccountService>());
        }

            public NinjectServiceScope(
                IResolutionRoot resolver,
                IEnumerable<IParameter> inheritedParameters)
            {
                _scope = new ScopeParameter();
                inheritedParameters = inheritedParameters.AddOrReplaceScopeParameter(_scope);
                _serviceProvider = new NinjectServiceProvider(resolver, inheritedParameters.ToArray());

                var httpContext = resolver.Get<IHttpContextAccessor>().HttpContext;

                if (httpContext != null)
                {
                    httpContext.Items.Add(typeof(ScopeParameter).FullName, _scope);
                }
            }

        public object GetAllAsList(IResolutionRoot resolutionRoot, Type type, IResolutionParameters resolutionParameters)
        {
            var listType = typeof(List<>).MakeGenericType(type).GetTypeInfo();
            var list = listType.DeclaredConstructors.Single(x => !x.GetParameters().Any()).Invoke(new object[0]);
            var addMethod = listType.GetDeclaredMethod("Add");

            IEnumerable<object> values = resolutionRoot.GetAll(type, resolutionParameters.Constraint, resolutionParameters.Parameters.ToArray());

            foreach (var value in values)
            {
                addMethod.Invoke(list, new[] { value });
            }

            return list;
        }

 public void Dispose()
 {
     //IDisposable disposable = resolver as IDisposable;
     //if (disposable != null)
     //    disposable.Dispose();
     resolver = null;
 }

 public void Dispose()
 {
     var disposable = _resolver as IDisposable;
     if (disposable != null)
         disposable.Dispose();
     _resolver = null;
 }

        public NinjectDependencyResolver()
        {
            IKernel kernel = new StandardKernel();
            resolutionRoot = kernel;

            DoBindings(kernel);
        }

 public void Dispose()
 {
     IDisposable disposable = resolver as IDisposable;
     if (disposable != null)
         disposable.Dispose();
     resolver = null;
 }

 public void Dispose()
 {
     var disposable = _resolutionRoot as IDisposable;
     if(disposable!=null)
         disposable.Dispose();
     _resolutionRoot = null;
 }

        public void Dispose()
        {
            var disposable = resolver as IDisposable;

            disposable?.Dispose();

            resolver = null;
        }

        public void Dispose()
        {
            var root = this.resolutionRoot as IDisposable;
            if (root != null)
                root.Dispose();

            resolutionRoot = null;
        }