public override void PreBuildUp(IBuilderContext context)
        {
            Guard.ArgumentNotNull(context, "context");
            if (!this.CanIntercept(context))
            {
                return;
            }
            IInstanceInterceptionPolicy interceptionPolicy = FindInterceptionPolicy <IInstanceInterceptionPolicy>(context, true);

            if (null == interceptionPolicy)
            {
                IInstanceInterceptor interceptor = context.NewBuildUp <IInterceptor>(typeof(IInterceptor).AssemblyQualifiedName) as IInstanceInterceptor;
                if (null == interceptor)
                {
                    return;
                }
                if (!interceptor.CanIntercept(context.BuildKey.Type))
                {
                    return;
                }
                context.Policies.Set <IInstanceInterceptionPolicy>(new FixedInstanceInterceptionPolicy(interceptor), context.BuildKey);
                context.Policies.Clear <ITypeInterceptionPolicy>(context.BuildKey);
            }

            IInterceptionBehaviorsPolicy interceptionBehaviorsPolicy = FindInterceptionPolicy <IInterceptionBehaviorsPolicy>(context, true);

            if (null == interceptionBehaviorsPolicy)
            {
                var policyInjectionBehavior = new InterceptionBehavior <PolicyInjectionBehavior>();
                policyInjectionBehavior.AddPolicies(context.OriginalBuildKey.Type, context.BuildKey.Type, context.BuildKey.Name, context.Policies);
            }
        }
        public override void PostBuildUp(IBuilderContext context)
        {
            Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(context, "context");

            // If it's already been intercepted, don't do it again.
            if (context.Existing is IInterceptingProxy)
            {
                return;
            }

            IInstanceInterceptionPolicy interceptionPolicy =
                FindInterceptionPolicy <IInstanceInterceptionPolicy>(context, true);

            if (interceptionPolicy == null)
            {
                return;
            }

            var interceptor = interceptionPolicy.GetInterceptor(context);

            IInterceptionBehaviorsPolicy interceptionBehaviorsPolicy =
                FindInterceptionPolicy <IInterceptionBehaviorsPolicy>(context, true);

            if (interceptionBehaviorsPolicy == null)
            {
                return;
            }

            IAdditionalInterfacesPolicy additionalInterfacesPolicy =
                FindInterceptionPolicy <IAdditionalInterfacesPolicy>(context, false);
            IEnumerable <Type> additionalInterfaces =
                additionalInterfacesPolicy != null ? additionalInterfacesPolicy.AdditionalInterfaces : Type.EmptyTypes;

            Type typeToIntercept    = context.OriginalBuildKey.Type;
            Type implementationType = context.Existing.GetType();

            IInterceptionBehavior[] interceptionBehaviors =
                interceptionBehaviorsPolicy.GetEffectiveBehaviors(
                    context, interceptor, typeToIntercept, implementationType)
                .ToArray();

            if (interceptionBehaviors.Length > 0)
            {
                context.Existing =
                    Intercept.ThroughProxyWithAdditionalInterfaces(
                        typeToIntercept,
                        context.Existing,
                        interceptor,
                        interceptionBehaviors,
                        additionalInterfaces);
            }
        }
Exemple #3
0
        /// <summary>
        /// Called during the chain of responsibility for a build operation. The
        /// PostBuildUp method is called when the chain has finished the PreBuildUp
        /// phase and executes in reverse order from the PreBuildUp calls.
        /// </summary>
        /// <param name="context">Context of the build operation.</param>
        public override void PostBuildUp(IBuilderContext context)
        {
            // If it's already been intercepted, don't do it again.
            if (context.Existing is IInterceptingProxy)
            {
                return;
            }

            Type originalType;

            if (!BuildKey.TryGetType(context.OriginalBuildKey, out originalType))
            {
                return;
            }

            Type typeToIntercept;
            IInstanceInterceptionPolicy interceptionPolicy = FindInterceptorPolicy(context, out typeToIntercept);

            if (interceptionPolicy != null)
            {
                IInstanceInterceptor interceptor = interceptionPolicy.Interceptor;
                if (interceptor.CanIntercept(typeToIntercept))
                {
                    IUnityContainer    container   = BuilderContext.NewBuildUp <IUnityContainer>(context);
                    InjectionPolicy[]  policies    = BuilderContext.NewBuildUp <InjectionPolicy[]>(context);
                    PolicySet          allPolicies = new PolicySet(policies);
                    IInterceptingProxy proxy       = interceptor.CreateProxy(typeToIntercept, context.Existing);
                    bool hasHandlers = false;
                    foreach (MethodImplementationInfo method in interceptor.GetInterceptableMethods(typeToIntercept, context.Existing.GetType()))
                    {
                        HandlerPipeline pipeline = new HandlerPipeline(allPolicies.GetHandlersFor(method, container));
                        if (pipeline.Count > 0)
                        {
                            proxy.SetPipeline(interceptor.MethodInfoForPipeline(method), pipeline);
                            hasHandlers = true;
                        }
                    }
                    if (hasHandlers)
                    {
                        context.Existing = proxy;
                    }
                }
            }
        }