C# IResolutionRoot类代码示例

        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 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;
        }