C# IBuilderContext.AddResolverOverrides方法代码示例

        public override void PreBuildUp(IBuilderContext context)
        {
            NamedTypeBuildKey key = context.OriginalBuildKey;

            if (!(key.Type.IsInterface && _typeStacks.ContainsKey(key.Type)))
            {
                return;
            }

            if (null != context.GetOverriddenResolver(key.Type))
            {
                return;
            }

            var stack = new Stack<Type>(_typeStacks[key.Type]);
            object value = null;
            stack.ForEach(type =>
            {
                value = context.NewBuildUp(new NamedTypeBuildKey(type, key.Name));
                var overrides = new DependencyOverride(key.Type, value);
                context.AddResolverOverrides(overrides);
            }
                );

            context.Existing = value;
            context.BuildComplete = true;
        }

 public override void PreBuildUp(IBuilderContext context)
 {
     var policy = context.Policies.Get<InterceptorPolicy>(context.BuildKey);
     if (policy != null)
     {
         ICollection<IDynamicInterceptor> interceptors = policy.RetrieveInterceptors(context);
         var dynamicInterceptorManager = new DynamicInterceptorManager(new DynamicInterceptorCollection(interceptors));
         context.AddResolverOverrides(new DependencyOverride<IDynamicInterceptorManager>(dynamicInterceptorManager));
     }
 }

        public override void PreBuildUp(IBuilderContext context)
        {
            Type typeToBuild = context.BuildKey.Type;

            if (typeToBuild.IsGenericType && typeof (IVisitor<>) == typeToBuild.GetGenericTypeDefinition())
            {
                AbstractVisitor abstractVisitor = new AbstractVisitor(context);

                context.Existing = abstractVisitor;

                context.AddResolverOverrides(new DependencyOverride(typeToBuild, abstractVisitor));
            }
        }

        /// <summary>
        /// Checks if resolvers need to be overriden.
        /// </summary>
        /// <param name="context">Context of the build operation.</param>
        public override void PreBuildUp(IBuilderContext context)
        {
            var typeToBuild = context.BuildKey.Type;
            //
            if (Logger.IsDebugEnabled)
            {
                Logger.Debug("StepScopeStrategy > PreBuildUp > typeToBuild :[{0}]", typeToBuild.FullName);
            }
            //
            if (typeToBuild.IsArray)
            {
                return;
            }

            var lifetimePolicy = context.Policies.GetNoDefault<ILifetimePolicy>(context.BuildKey, false);
            if (lifetimePolicy is StepScopeLifetimeManager)
            {
                // the object being built is in the step scope, we don't need proxies for its dependencies
                return;
            }


            // Constructor parameters resolvers
            var constructorParameters = new Dictionary<string, StepScopeDependency>();
            IPolicyList resolverPolicyDestination;
            var constructorSelector = context.Policies.Get<IConstructorSelectorPolicy>(context.BuildKey, out resolverPolicyDestination);
            var constructor = constructorSelector.SelectConstructor(context, resolverPolicyDestination);
            if (constructor != null)
            {
                ResolveConstructorParameters(constructor, constructorParameters);
            }

            // Properties resolvers
            var properties = new Dictionary<string, StepScopeDependency>();
            var propertySelector = context.Policies.Get<IPropertySelectorPolicy>(context.BuildKey, out resolverPolicyDestination);
            ResolveProperties(context, propertySelector, resolverPolicyDestination, properties);

            // Method parameters resolvers
            var methodParameters = new Dictionary<Tuple<string, string>, IList<StepScopeDependency>>();
            var methodSelector = context.Policies.Get<IMethodSelectorPolicy>(context.BuildKey, out resolverPolicyDestination);
            ResolveMethodParameters(context, methodSelector, resolverPolicyDestination, methodParameters);

            if (constructorParameters.Any() || properties.Any() || methodParameters.Any())
            {
                context.AddResolverOverrides(new StepScopeOverride(constructorParameters, properties, methodParameters));
            }
        }

        /// <summary>
        /// A convenience method to do a new buildup operation on an existing context. This
        /// overload allows you to specify extra policies which will be in effect for the duration
        /// of the build.
        /// </summary>
        /// <param name="newBuildKey">Key defining what to build up.</param>
        /// <param name="childCustomizationBlock">A delegate that takes a <see cref="IBuilderContext"/>. This
        /// is invoked with the new child context before the build up process starts. This gives callers
        /// the opportunity to customize the context for the build process.</param>
        /// <returns>Created object.</returns>
        public object NewBuildUp(NamedTypeBuildKey newBuildKey, Action<IBuilderContext> childCustomizationBlock)
        {
            ChildContext =
                new BuilderContext(chain, lifetime, persistentPolicies, policies, newBuildKey, null);

            ChildContext.AddResolverOverrides(Sequence.Collect(resolverOverrides));

            childCustomizationBlock(ChildContext);

            object result = ChildContext.Strategies.ExecuteBuildUp(ChildContext);

            ChildContext = null;

            return result;
        }