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

            if (!key.Type.IsInterface)
            {
                // We only record for interfaces
                return;
            }

            var existing = context.Existing;

            if (existing == null)
            {
                return;
            }

            if (_settings.InterestingTypes.Count > 0)
            {
                if (!_settings.InterestingTypes.Contains(key.Type.FullName))
                {
                    return;
                }
            }

            Debug.WriteLine("Instantiated " + existing.GetType().FullName);
            Debug.WriteLine("ResolvedFrom " + key.Type.FullName);

            var replacement = _recorder.Record(context.OriginalBuildKey.Type, context.Existing);

            Debug.WriteLine("ReplacedWith " + replacement.GetType().FullName);

            context.Existing = replacement;
        }

        public override void PreBuildUp(IBuilderContext context)
        {
            var type = context.BuildKey.Type;
            if (!type.FullName.StartsWith("Microsoft.Practices"))
            {
                var properties = type.GetProperties();

                foreach (var property in properties)
                {
                    if (!property.CanWrite)
                        continue;

                    if (_unityContainer.IsRegistered(property.PropertyType))
                    {
                        property.SetValue(context.Existing, _unityContainer.Resolve(property.PropertyType),null);
                    }

                    if(configuredProperties.ContainsKey(type))
                    {
                        var p = configuredProperties[type].FirstOrDefault(t => t.Item1 == property.Name);

                        if(p != null)
                            property.SetValue(context.Existing, p.Item2,null);
                    }
                }
            }
        }

        /// <summary>Builds the dependency demands required by this implementation. </summary>
        /// <param name="containerBuilder">The <see cref="IContainerBuilder"/> .</param>
        /// <param name="context">The context for this building session containing configuration etc.</param>
        public void Build(IContainerBuilder containerBuilder, IBuilderContext context)
        {
            containerBuilder
                .ForFactory(x => new IndexConfiguration(context.MapPath("~/App_Data/DiskCaches/Lucene/")))
                .KnownAsSelf()
                .ScopedAs.Singleton();

            //containerBuilder
            //    .ForFactory(x => new IndexController(x.Resolve<IndexConfiguration>(), null))
            //    .KnownAsSelf()
            //    .OnActivated((ctx, ctrlr) =>
            //    {
            //        var frameworkContext = ctx.Resolve<IFrameworkContext>();
            //        ctrlr.SetFrameworkContext(frameworkContext);
            //    })
            //    .ScopedAs.Singleton();

            containerBuilder
                .ForFactory(x => new IndexController(x.Resolve<IndexConfiguration>(), x.Resolve<IFrameworkContext>))
                .KnownAsSelf()
                //.OnActivated((ctx, ctrlr) =>
                //{
                //    var frameworkContext = ctx.Resolve<IFrameworkContext>();
                //    ctrlr.SetFrameworkContext(frameworkContext);
                //})
                .ScopedAs.Singleton();
        }

            public override void PostBuildUp(IBuilderContext context)
            {
                base.PostBuildUp(context);

                Type targetType = context.Existing.GetType();

                if (!_trackabilityCache.ContainsKey(targetType))
                    _trackabilityCache[targetType] =
                        targetType.GetInterfaces().Contains(typeof(ITrackingAware)) ||
                        targetType.GetProperties().Any(p => p.GetCustomAttributes(true).OfType<TrackableAttribute>().Count() > 0);

                if (_trackabilityCache[targetType])
                {
                    List<StateTracker> trackers = new List<StateTracker>(_container.ResolveAll<StateTracker>());
                    if (_container.IsRegistered<StateTracker>())
                        trackers.Add(_container.Resolve<StateTracker>());

                    foreach (StateTracker tracker in trackers)
                    {
                        var config = tracker.Configure(context.Existing);
                        _customizeConfigAction(config);
                        config.Apply();
                    }
                }
            }

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

        private WorkItem GetWorkItem(IBuilderContext context, object item)
        {
            if (item is WorkItem)
                return item as WorkItem;

            return context.Locator.Get<WorkItem>(new DependencyResolutionLocatorKey(typeof(WorkItem), null));
        }

        /// <summary>
        /// Initializes the provider and ensures that all configuration can be read
        /// </summary>
        /// <param name="builderContext"></param>
        public override void Initialise(IBuilderContext builderContext)
        {
            Mandate.ParameterNotNull(builderContext, "builderContext");

            var configMain = builderContext.ConfigurationResolver.GetConfigSection(HiveConfigSection.ConfigXmlKey) as HiveConfigSection;

            if (configMain == null)
                throw new ConfigurationErrorsException(
                    string.Format("Configuration section '{0}' not found when building packaging provider '{1}'",
                                  HiveConfigSection.ConfigXmlKey, ProviderKey));

            var config2Rw = configMain.Providers.ReadWriters[ProviderKey] ?? configMain.Providers.Readers[ProviderKey];

            if (config2Rw == null)
                throw new ConfigurationErrorsException(
                    string.Format("No configuration found for persistence provider '{0}'", ProviderKey));

            //get the Hive provider config section
            _localConfig = DeepConfigManager.Default.GetFirstPluginSection<ProviderConfigurationSection>(config2Rw.ConfigSectionKey);

            if (!ValidateProviderConfigSection<MembershipDemandBuilder>(_localConfig, config2Rw))
            {
                CanBuild = false;
                return;
            }

            CanBuild = true;
        }

        /// <summary>
        /// Implementation of <see cref="IBuilderStrategy.BuildUp"/>. Sets the property values.
        /// </summary>
        /// <param name="context">The build context.</param>
        /// <param name="typeToBuild">The type being built.</param>
        /// <param name="existing">The object on which to inject property values.</param>
        /// <param name="idToBuild">The ID of the object being built.</param>
        /// <returns>The built object.</returns>
        public override object BuildUp(IBuilderContext context, Type typeToBuild, object existing, string idToBuild)
        {
            if (existing != null)
                InjectProperties(context, existing, idToBuild);

            return base.BuildUp(context, typeToBuild, existing, idToBuild);
        }

        /// <summary>
        /// See <see cref="IPropertySetterInfo.SelectProperty"/> for more information.
        /// </summary>
        public PropertyInfo SelectProperty(IBuilderContext context, Type type, string id)
        {
            if (prop != null)
                return prop;

            return type.GetProperty(name);
        }

        /// <summary>
        /// Called during the chain of responsibility for a build operation. The
        ///             PreBuildUp method is called when the chain is being executed in the
        ///             forward direction.
        /// </summary>
        /// <param name="context">Context of the build operation.</param>
        public override void PreBuildUp(IBuilderContext context)
        {
            if (context == null) throw new ArgumentNullException("context");

            var key = context.BuildKey;

            if(!RequestIsForValidatorOfT(key)) return;

            var typeToValidate = TypeToValidate(key.Type);
            var rulesetName = key.Name;

            var validatorFactory = GetValidatorFactory(context);

            Validator validator;

            if(string.IsNullOrEmpty(rulesetName))
            {
                validator = validatorFactory.CreateValidator(typeToValidate);
            }
            else
            {
                validator = validatorFactory.CreateValidator(typeToValidate, rulesetName);
            }

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

        private ValidatorFactory GetValidatorFactory(IBuilderContext context)
        {
            var validationSpecificationSource = ValidationSource(context);

            if(validationSpecificationSource == 0)
            {
                throw new InvalidOperationException(
                    string.Format(CultureInfo.CurrentCulture, 
                    Resources.InvalidValidationSpecificationSource, validationSpecificationSource));
            }

            if(validationSpecificationSource == ValidationSpecificationSource.All)
            {
                return context.NewBuildUp<ValidatorFactory>();
            }

            var factories = new List<ValidatorFactory>();

            if((validationSpecificationSource & ValidationSpecificationSource.Attributes) != 0)
            {
                factories.Add(context.NewBuildUp<AttributeValidatorFactory>());
            }
            if((validationSpecificationSource & ValidationSpecificationSource.Configuration) != 0)
            {
                factories.Add(context.NewBuildUp<ConfigurationValidatorFactory>());
            }
            if((validationSpecificationSource & ValidationSpecificationSource.DataAnnotations) != 0)
            {
                factories.Add(context.NewBuildUp<ValidationAttributeValidatorFactory>());
            }

            return new CompositeValidatorFactory(GetInstrumentationProvider(context), factories);
        }

        /// <summary>
        /// Implementation of <see cref="IBuilderStrategy.BuildUp"/>.
        /// </summary>
        /// <param name="context">The build context.</param>
        /// <param name="typeToBuild">The type of the object being built.</param>
        /// <param name="existing">The existing instance of the object.</param>
        /// <param name="idToBuild">The ID of the object being built.</param>
        /// <returns>The built object.</returns>
        public override object BuildUp(
			IBuilderContext context, Type typeToBuild, object existing, string idToBuild)
        {
            IBuildPlan buildPlan = GetPlanFromContext(context, typeToBuild, idToBuild);
            existing = buildPlan.BuildUp(context, typeToBuild, existing, idToBuild);
            return base.BuildUp(context, typeToBuild, existing, idToBuild);
        }

        public void Build(IContainerBuilder containerBuilder, IBuilderContext context)
        {
            containerBuilder.For<MapResolverContext>().KnownAsSelf().ScopedAs.Singleton();

            // register the model mappers
            containerBuilder.For<RenderTypesModelMapper>()
                .KnownAs<AbstractMappingEngine>()
                .WithMetadata<TypeMapperMetadata, bool>(x => x.MetadataGeneratedByMapper, true)
                .ScopedAs.Singleton();

            containerBuilder
                .For<FrameworkModelMapper>()
                .KnownAs<AbstractMappingEngine>()
                .WithMetadata<TypeMapperMetadata, bool>(x => x.MetadataGeneratedByMapper, true)
                .ScopedAs.Singleton();

            //register model mapper for security model objects
            containerBuilder
                .For<SecurityModelMapper>()
                .KnownAs<AbstractMappingEngine>()
                .WithMetadata<TypeMapperMetadata, bool>(x => x.MetadataGeneratedByMapper, true)
                .ScopedAs.Singleton();

            //register model mapper for web model objects
            containerBuilder
                .For<CmsModelMapper>()
                .KnownAs<AbstractMappingEngine>()
                .WithMetadata<TypeMapperMetadata, bool>(x => x.MetadataGeneratedByMapper, true)
                .ScopedAs.Singleton();
        }

        private void ApplyPolicy(IBuilderContext context, object obj, string id)
        {
            if (obj == null)
                return;

            Type type = obj.GetType();
            IMethodPolicy policy = context.Policies.Get<IMethodPolicy>(type, id);

            if (policy == null)
                return;

            foreach (IMethodCallInfo methodCallInfo in policy.Methods.Values)
            {
                MethodInfo methodInfo = methodCallInfo.SelectMethod(context, type, id);

                if (methodInfo != null)
                {
                    object[] parameters = methodCallInfo.GetParameters(context, type, id, methodInfo);
                    Guard.ValidateMethodParameters(methodInfo, parameters, obj.GetType());

                    if (TraceEnabled(context))
                        TraceBuildUp(context, type, id, Properties.Resources.CallingMethod, methodInfo.Name, ParametersToTypeList(parameters));

                    methodInfo.Invoke(obj, parameters);
                }
            }
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="context">The builder context in which the resolver will resolve
        /// dependencies.</param>
        public DependencyResolver(IBuilderContext context)
        {
            if (context == null)
                throw new ArgumentNullException("context");

            this.context = context;
        }

            public override void PreBuildUp(IBuilderContext context)
            {
                var policy = BuildTracking.GetPolicy(context)
                    ?? BuildTracking.SetPolicy(context);

                policy.BuildKeys.Push(context.BuildKey);
            }

        /// <summary>
        /// Returns a <see cref="StepScopeResolverPolicy"/> for dependencies in the step scope.
        /// </summary>
        /// <param name="context">the current build context</param>
        /// <param name="dependencyType">the type of dependency</param>
        /// <returns>a <see cref="StepScopeResolverPolicy"/> if the dependency being resolved in is step scope; null otherwise</returns>
        public override IDependencyResolverPolicy GetResolver(IBuilderContext context, Type dependencyType)
        {
            var constructorParameterOperation = context.CurrentOperation as ConstructorArgumentResolveOperation;
            StepScopeDependency dependency;
            if (constructorParameterOperation != null &&
                _constructorParameters.TryGetValue(constructorParameterOperation.ParameterName, out dependency))
            {
                return new StepScopeResolverPolicy(dependency);
            }

            var propertyValueOperation = context.CurrentOperation as ResolvingPropertyValueOperation;
            if (propertyValueOperation != null && _properties.TryGetValue(propertyValueOperation.PropertyName, out dependency))
            {
                return new StepScopeResolverPolicy(dependency);
            }

            var methodParameterOperation = context.CurrentOperation as MethodArgumentResolveOperation;
            if (methodParameterOperation != null && 
                TryGetMethodParameterDependency(
                    new Tuple<string, string>(methodParameterOperation.MethodSignature, methodParameterOperation.ParameterName),
                    out dependency))
            {
                return new StepScopeResolverPolicy(dependency);
            }

            return null;
        }

 /// <summary>
 /// Get the value for a dependency.
 /// </summary>
 /// <param name="context">Current build context.</param>
 /// <returns>
 /// The value for the dependency.
 /// </returns>
 public object Resolve(IBuilderContext context)
 {
     return context.NewBuildUp(new NamedTypeBuildKey(validatorType, ruleSet),
         newContext => newContext.Policies.Set(
             new ValidationSpecificationSourcePolicy(validationSource),
             new NamedTypeBuildKey(validatorType, ruleSet)));
 }

        public object CreateObject(IBuilderContext context, string name, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
        {
            MockTraceListenerClient createdObject = new MockTraceListenerClient();
            createdObject.traceListener = TraceListenerCustomFactory.Instance.Create(context, name, configurationSource, reflectionCache);

            return createdObject;
        }

 private void InjectProperties(IBuilderContext context, object obj, string id)
 {
     if (obj != null)
     {
         Type typePolicyAppliesTo = obj.GetType();
         IPropertySetterPolicy policy = context.Policies.Get<IPropertySetterPolicy>(typePolicyAppliesTo, id);
         if (policy != null)
         {
             foreach (IPropertySetterInfo info in policy.Properties.Values)
             {
                 PropertyInfo propInfo = info.SelectProperty(context, typePolicyAppliesTo, id);
                 if (propInfo != null)
                 {
                     if (!propInfo.CanWrite)
                     {
                         throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.CannotInjectReadOnlyProperty, new object[] { typePolicyAppliesTo, propInfo.Name }));
                     }
                     object obj2 = info.GetValue(context, typePolicyAppliesTo, id, propInfo);
                     if (obj2 != null)
                     {
                         Guard.TypeIsAssignableFromType(propInfo.PropertyType, obj2.GetType(), obj.GetType());
                     }
                     if (base.TraceEnabled(context))
                     {
                         base.TraceBuildUp(context, typePolicyAppliesTo, id, Resources.CallingProperty, new object[] { propInfo.Name, propInfo.PropertyType.Name });
                     }
                     propInfo.SetValue(obj, obj2, null);
                 }
             }
         }
     }
 }