/// <summary>
		/// Creates the <see cref="ISessionFactory"/> from the configuration
		/// </summary>
		/// <param name="context"></param>
		/// <returns></returns>
		public override object Create(CreationContext context)
		{
			RaiseCreatingSessionFactory();
			var configuration = Model.ExtendedProperties[Constants.SessionFactoryConfiguration]
			                    as Configuration;
			return configuration.BuildSessionFactory();
		}

 public object Resolve(CreationContext context, ISubDependencyResolver parentResolver,
     ComponentModel model,
     DependencyModel dependency)
 {
     Type t = dependency.TargetType.GetGenericArguments()[0];
     return kernel.ResolveAll(t, null);
 }

		protected override object Instantiate(CreationContext context)
		{
			String accessor = (String) Model.ExtendedProperties["instance.accessor"];

			PropertyInfo pi = Model.Implementation.GetProperty( 
				accessor, BindingFlags.Public|BindingFlags.Static );

			if (pi == null)
			{
				String message = String.Format("You have specified an instance accessor " + 
					"for the component '{0}' {1} which could not be found (no public " + 
					"static property has this name)", Model.Name, Model.Implementation.FullName);
				throw new FacilityException(message);
			}

			if (!pi.CanRead)
			{
				String message = String.Format("You have specified an instance accessor " + 
					"for the component '{0}' {1} which is write-only", 
					Model.Name, Model.Implementation.FullName);
				throw new FacilityException(message);
			}

			try
			{
				return pi.GetValue( null, new object[0] );
			}
			catch(Exception ex)
			{
				String message = String.Format("The instance accessor " + 
					"invocation failed for '{0}' {1}", 
					Model.Name, Model.Implementation.FullName);
				throw new FacilityException(message, ex);
			}
		}

        public override object Resolve(CreationContext context)
        {
            var current = HttpContext.Current;
            if (current == null)
                throw new InvalidOperationException("HttpContext.Current is null. PerHttpApplicationLifestyle can only be used in ASP.NET");

            var app = current.ApplicationInstance;
            var lifestyleModule = app.Modules
                .Cast<string>()
                .Select(k => app.Modules[k])
                .OfType<PerHttpApplicationLifestyleModule>()
                .FirstOrDefault();
            if (lifestyleModule == null) {
                var message = string.Format("Looks like you forgot to register the http module {0}" +
                                               "\r\nAdd '<add name=\"PerHttpApplicationLifestyle\" type=\"{1}\" />' " +
                                               "to the <httpModules> section on your web.config",
                                               typeof (PerWebRequestLifestyleModule).FullName,
                                               typeof (PerWebRequestLifestyleModule).AssemblyQualifiedName);
                throw new ConfigurationErrorsException(message);
            }

            if (!lifestyleModule.HasComponent(PerAppObjectID)) {
                var instance = base.Resolve(context);
                lifestyleModule[PerAppObjectID] = instance;
                app.Disposed += (sender, args) => base.Release(instance);
            }

            return lifestyleModule[PerAppObjectID];
        }

		protected override object Instantiate(CreationContext context)
		{
			String factoryId = (String)Model.ExtendedProperties["factoryId"];
			String factoryCreate = (String)Model.ExtendedProperties["factoryCreate"];

			if (!Kernel.HasComponent(factoryId))
			{
				String message = String.Format("You have specified a factory ('{2}') " +
					"for the component '{0}' {1} but the kernel does not have this " +
					"factory registered",
					Model.Name, Model.Implementation.FullName, factoryId);
				throw new FacilityException(message);
			}

			IHandler factoryHandler = Kernel.GetHandler(factoryId);

			// Let's find out whether the create method is a static or instance method

			Type factoryType = factoryHandler.ComponentModel.Implementation;

			MethodInfo staticCreateMethod =
				factoryType.GetMethod(factoryCreate,
					BindingFlags.Public | BindingFlags.Static);

			if (staticCreateMethod != null)
			{
				return Create(null, factoryId, staticCreateMethod, factoryCreate, context);
			}
			else
			{
				object factoryInstance = Kernel[factoryId];

				MethodInfo instanceCreateMethod =
					factoryInstance.GetType().GetMethod(factoryCreate,
						BindingFlags.Public | BindingFlags.Instance);

				if (instanceCreateMethod == null)
				{
					factoryInstance = ProxyUtil.GetUnproxiedInstance(factoryInstance);

					instanceCreateMethod =
						factoryInstance.GetType().GetMethod(factoryCreate,
							BindingFlags.Public | BindingFlags.Instance);
				}

				if (instanceCreateMethod != null)
				{
					return Create(factoryInstance, factoryId, instanceCreateMethod, factoryCreate, context);
				}
				else
				{
					String message = String.Format("You have specified a factory " +
					                               "('{2}' - method to be called: {3}) " +
					                               "for the component '{0}' {1} but we couldn't find the creation method" +
					                               "(neither instance or static method with the name '{3}')",
					                               Model.Name, Model.Implementation.FullName, factoryId, factoryCreate);
					throw new FacilityException(message);
				}
			}
		}

		public object Resolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
							  DependencyModel dependency)
		{
			Type elementType = dependency.TargetType.GetElementType();
			Array all = kernel.ResolveAll(elementType, new Hashtable());
			return all;
		}

		protected override object InternalCreate(CreationContext context)
		{
			String fileName = (String) Model.ExtendedProperties[IBatisNetFacility.MAPPER_CONFIG_FILE];
			bool isEmbedded = (bool) Model.ExtendedProperties[IBatisNetFacility.MAPPER_CONFIG_EMBEDDED];
			String connectionString = (String) Model.ExtendedProperties[IBatisNetFacility.MAPPER_CONFIG_CONNECTION_STRING];

			DomSqlMapBuilder domSqlMapBuilder = new DomSqlMapBuilder();
			ISqlMapper sqlMapper;

			if (isEmbedded)
			{
				XmlDocument sqlMapConfig = Resources.GetEmbeddedResourceAsXmlDocument(fileName);
				sqlMapper = domSqlMapBuilder.Configure(sqlMapConfig);
			}
			else
			{
				sqlMapper = domSqlMapBuilder.Configure(fileName);
			}

			if (connectionString != null && connectionString.Length > 0)
			{
				sqlMapper.DataSource.ConnectionString = connectionString;
			}


			if (sqlMapper != null)
			{
				return sqlMapper;
			}
			else
			{
				throw new FacilityException(string.Format("The IBatisNetIntegration Facility was unable to successfully configure SqlMapper ID [{0}] with File [{1}] that was set to Embedded [{2}].", Model.Name, Model.ExtendedProperties[IBatisNetFacility.MAPPER_CONFIG_FILE].ToString(), Model.ExtendedProperties[IBatisNetFacility.MAPPER_CONFIG_EMBEDDED].ToString()));
			}
		}

        public override object Resolve(CreationContext context)
        {
            var store = GetStore();

            var instance = base.Resolve(context);

            if (instance == null)
            {
                if (context.Handler.ComponentModel.ExtendedProperties[Constants.REG_IS_INSTANCE_KEY] != null)
                {
                    throw new DependencyResolutionException("Cannot find the instance in the context store.");
                }
            }
            else if (store[Model.Name] == null)
            {
                store[Model.Name] = instance;
                store.GetContextInstances().Add(new ContextStoreDependency(Model.Name, instance, this));
                _isRegisteredForCleanup = true;
            }

            if (!_isRegisteredForCleanup)
            {
                store.GetContextInstances().Add(new ContextStoreDependency(Model.Name, instance, this));
                _isRegisteredForCleanup = true;
            }
            return store[Model.Name];
        }

		public object Resolve(CreationContext context,
		                      ISubDependencyResolver parentResolver,
		                      ComponentModel model,
		                      DependencyModel dependency)
		{
			return _kernel.ResolveAll(dependency.TargetType.GetElementType(), null);
		}

			public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
			                      DependencyModel dependency)
			{
				return contextHandlerResolver.Resolve(context, contextHandlerResolver, model,
				                                      new DependencyModel(DependencyType.Service, typeof(IBookStore).FullName,
				                                                          typeof(IBookStore), false));
			}

        public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
                               DependencyModel dependency)
        {

            return Context.CurrentUser != null &&
                   dependency.TargetType == typeof (INotifications);
        }

        /// <summary>
        /// Resolves the specified context.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <returns></returns>
        public override object Resolve(CreationContext context)
        {
            if (HttpContext.Current == null)
            {
                throw new InvalidOperationException("HttpContext.Current is null. ScopeWebRequestLifestyleManager can only be used in ASP.NET");
            }
            
            string name = (ComponentActivator as AbstractComponentActivator).Model.Name;

            if (_requestScope[name] == null)
            {
                if (!ScopeLifestyleModule.Initialized)
                {
                    string message = "Looks like you forgot to register the http module " +
                        typeof(ScopeLifestyleModule).FullName +
                        "\r\nAdd '<add name=\"ScopeLifestyleModule\" type=\"Castle.Igloo.LifestyleManager.ScopeLifestyleModule, Castle.Igloo\" />' " +
                        "to the <httpModules> section on your web.config";
                    {
					    throw new ConfigurationErrorsException(message);
                    }

                }

                object instance = base.Resolve(context);

                _requestScope.Add(name, instance);
                ScopeLifestyleModule.RegisterForRequestEviction(this, name, instance);
            }

            return _requestScope[name];
        }

 public object Resolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
     DependencyModel dependency)
 {
     if (dependency.TargetType == typeof (ISession))
         return SessionFactory.OpenSession();
     return SessionFactory.OpenStatelessSession();
 }

		protected override object Instantiate(CreationContext context)
		{
			object instance = base.Instantiate(context);

			Marshal(instance, Model);

			return instance;
		}

 public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver,
                        ComponentModel model,
                        DependencyModel dependency)
 {
     return dependency.TargetType != null &&
            dependency.TargetType.IsArray &&
            dependency.TargetType.GetElementType().IsInterface;
 }

        public override object Create(CreationContext context, Type type)
        {
            var types = new List<Type>(_extraInterfaces.Length + 1);
              types.Add(type);
              types.AddRange(_extraInterfaces);

              return MockFactory.GenerateDynamicMock(types.ToArray());
        }

		protected override object Instantiate(CreationContext context)
		{
			String url = (String) Model.ExtendedProperties["remoting.uri"];

			// return Activator.GetObject(Model.Service, url);

			return RemotingServices.Connect( Model.Service, url );
		}

        protected override object CreateInstance(CreationContext context, object[] arguments, System.Type[] signature)
        {
            // TODO: Support interceptors + copy "use fast create instance" logic from DefaultComponentActivator

            // Support internal and private constructors
            return Activator.CreateInstance(Model.Implementation,
                                            BindingFlags.CreateInstance | BindingFlags.NonPublic | BindingFlags.Public |
                                            BindingFlags.Instance, null, arguments, null, null);
        }

        public override object Resolve(CreationContext context)
        {
            // Retrieve from Session, or if not found, resolve via container.
            object result = HttpContext.Current.Session[uniqueKey];

            if (result == null)
                result = HttpContext.Current.Session[uniqueKey] = base.Resolve(context);

            return result;
        }

		protected override object Instantiate(CreationContext context)
		{
			object instance = base.Instantiate(context);

			object behavior = ProxyUtil.GetUnproxiedInstance(instance);
			WcfExtensionScope scope = WcfUtils.GetScope(Model);
			WcfUtils.ExtendBehavior(Kernel, scope, behavior);

			return instance;
		}