public virtual object Resolve(CreationContext context, Burden burden, IReleasePolicy releasePolicy)
		{
			var instance = CreateInstance(context, burden);
			Track(burden, releasePolicy);
			return instance;

		}

        public ILifetimeScope GetScope(CreationContext context)
        {
            var messageContext = MessageContext.Current;

            if (messageContext == null)
            {
                throw new InvalidOperationException(string.Format("Attempted to resolve {0} outside of Rebus message context!", context.RequestedType));
            }

            var items = messageContext.TransactionContext.Items;

            object lifetimeScope;

            if (items.TryGetValue(LifestimeScopeItemKey, out lifetimeScope))
            {
                return (ILifetimeScope) lifetimeScope;
            }

            var defaultLifetimeScope = new DefaultLifetimeScope();

            items[LifestimeScopeItemKey] = defaultLifetimeScope;

            messageContext.TransactionContext.OnDisposed(() => defaultLifetimeScope.Dispose());

            return defaultLifetimeScope;
        }

		private object GetNewInstance(CreationContext context, IReleasePolicy releasePolicy)
		{
			var burden = CreateInstance(context, true);
			cachedBurden = burden;
			Track(burden, releasePolicy);
			return burden.Instance;
		}

 public Type[] GetGenericArguments(ComponentModel model, CreationContext context)
 {
     //LuceneSession<Foo>
     Type sessionType = context.GenericArguments[0];
     Type modelType = sessionType.GetGenericArguments()[0];
     return new[] { modelType };
 }

		public virtual object Resolve(CreationContext context, IReleasePolicy releasePolicy)
		{
			var burden = CreateInstance(context, false);
			Track(burden, releasePolicy);
			return burden.Instance;

		}

		public override object Resolve(CreationContext context, IReleasePolicy releasePolicy)
		{
			// 1. read from cache
			if (cachedBurden != null)
			{
				return cachedBurden.Instance;
			}
			var instanceFromContext = context.GetContextualProperty(ComponentActivator);
			if (instanceFromContext != null)
			{
				//we've been called recursively, by some dependency from base.Resolve call
				return instanceFromContext;
			}

			var initializing = false;
			try
			{
				initializing = init.ExecuteThreadSafeOnce();
				if (cachedBurden != null)
				{
					return cachedBurden.Instance;
				}
				var burden = CreateInstance(context, true);
				cachedBurden = burden;
				Track(burden, releasePolicy);
				return burden.Instance;
			}
			finally
			{
				if (initializing)
				{
					init.EndThreadSafeOnceSection();
				}
			}
		}

		public override object Resolve(CreationContext context, IReleasePolicy releasePolicy)
		{
			// 1. read from cache
			if (cachedBurden != null)
			{
				return cachedBurden.Instance;
			}
			var initializing = false;
			try
			{
				initializing = init.ExecuteThreadSafeOnce();
				if (cachedBurden != null)
				{
					return cachedBurden.Instance;
				}
				var burden = CreateInstance(context, true);
				cachedBurden = burden;
				Track(burden, releasePolicy);
				return burden.Instance;
			}
			finally
			{
				if (initializing)
				{
					init.EndThreadSafeOnceSection();
				}
			}
		}

		public override object Resolve(CreationContext context, Burden burden, IReleasePolicy releasePolicy)
		{
			if (cachedBurden != null)
			{
				return cachedBurden.Instance;
			}
			var instanceFromContext = context.GetContextualProperty(ComponentActivator);
			if (instanceFromContext != null)
			{
				//we've been called recursively, by some dependency from base.Resolve call
				return instanceFromContext;
			}
			object instance;
			lock (ComponentActivator)
			{
				if (cachedBurden != null)
				{
					return cachedBurden.Instance;
				}
				instance = base.CreateInstance(context, burden);
				cachedBurden = burden;
			}
			Track(burden, releasePolicy);
			return instance;
		}

		public object Create(IProxyFactoryExtension customFactory, IKernel kernel, ComponentModel model,
		                     CreationContext context, params object[] constructorArguments)
		{
			throw new NotImplementedException(
				"You must supply an implementation of IProxyFactory " +
				"to use interceptors on the Microkernel");
		}

		protected IHandler GetSubHandler(CreationContext context, Type genericType)
		{
			lock (type2SubHandler)
			{
				IHandler handler;

				if (type2SubHandler.ContainsKey(genericType))
				{
					handler = type2SubHandler[genericType];
				}
				else
				{
					Type service = ComponentModel.Service.MakeGenericType(context.GenericArguments);

					ComponentModel newModel = Kernel.ComponentModelBuilder.BuildModel(
						ComponentModel.Name, service, genericType, ComponentModel.ExtendedProperties);

					newModel.ExtendedProperties[ComponentModel.SkipRegistration] = true;
					CloneParentProperties(newModel);

					// Create the handler and add to type2SubHandler before we add to the kernel.
					// Adding to the kernel could satisfy other dependencies and cause this method
					// to be called again which would result in extra instances being created.
					handler = Kernel.HandlerFactory.Create(newModel);
					type2SubHandler[genericType] = handler;

					Kernel.AddCustomComponent(newModel);
				}

				return handler;
			}
		}

        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 Exception(message);
            }

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

            return lifestyleModule[PerAppObjectID];
        }

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

            var instance = base.Resolve(context);

            if (instance == null)
            {
                if (context.Handler.ComponentModel.ExtendedProperties[Constants.RegIsInstanceKey] != 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));
                this.registeredForCleanup = true;
            }

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

            return store[Model.Name];
        }

		/// <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 virtual object Request(CreationContext context, Func<CreationContext, Burden> creationCallback)
		{
			using (rwlock.ForWriting())
			{
				if (!initialized)
				{
					Intitialize(creationCallback, context);
				}

				Burden burden;
				if (available.Count != 0)
				{
					burden = available.Pop();
					context.AttachExistingBurden(burden);
				}
				else
				{
					burden = creationCallback.Invoke(context);
				}
				try
				{
					inUse.Add(burden.Instance, burden);
				}
				catch (NullReferenceException)
				{
					throw new PoolException("creationCallback didn't return a valid burden");
				}
				catch (ArgumentNullException)
				{
					throw new PoolException("burden returned by creationCallback does not have root instance associated with it (its Instance property is null).");
				}
				return burden.Instance;
			}
		}

		private bool CanResolvePendingDependencies(CreationContext context)
		{
			if (CurrentState == HandlerState.Valid)
			{
				return true;
			}
			// detect circular dependencies
			if (IsBeingResolvedInContext(context))
			{
				return context.HasAdditionalParameters;
			}
			var canResolveAll = true;
			foreach (var dependency in DependenciesByService.Values.ToArray())
			{
				
				// a self-dependency is not allowed
				var handler = Kernel.LazyLoadComponentByType(dependency.DependencyKey, dependency.TargetItemType, context.AdditionalParameters);
				if (handler == this || handler == null)
				{
					canResolveAll = false;
					break;
				}
			}
			return (canResolveAll && DependenciesByKey.Count == 0) || context.HasAdditionalParameters;
		}

		/// <summary>
		///   Returns true if the resolver is able to satisfy the specified dependency.
		/// </summary>
		/// <param name = "context">Creation context, which is a resolver itself</param>
		/// <param name = "contextHandlerResolver">Parent resolver</param>
		/// <param name = "model">Model of the component that is requesting the dependency</param>
		/// <param name = "dependency">The dependency model</param>
		/// <returns>
		///   <c>true</c>
		///   if the dependency can be satisfied</returns>
		public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
		{
			// 1 - check for the dependency on CreationContext, if present
			if (CanResolveFromContext(context, contextHandlerResolver, model, dependency))
			{
				return true;
			}

			// 2 - check with the model's handler, if not the same as the parent resolver
			if (CanResolveFromHandler(context, contextHandlerResolver, model, dependency))
			{
				return true;
			}

			// 3 - check within parent resolver, if present
			if (CanResolveFromContextHandlerResolver(context, contextHandlerResolver, model, dependency))
			{
				return true;
			}

			// 4 - check within subresolvers
			if (CanResolveFromSubResolvers(context, contextHandlerResolver, model, dependency))
			{
				return true;
			}

			// 5 - normal flow, checking against the kernel
			return CanResolveFromKernel(context, model, dependency);
		}

		public override object Resolve(CreationContext context)
		{
			var current = HttpContext.Current;

			if (current == null)
				throw new InvalidOperationException(
					"HttpContext.Current is null. PerWebRequestLifestyle can only be used in ASP.Net");

			if (current.Items[PerRequestObjectID] == null)
			{
				if (!PerWebRequestLifestyleModule.Initialized)
				{
					var message =
						string.Format(
							"Looks like you forgot to register the http module {0}{1}Add '<add name=\"PerRequestLifestyle\" type=\"Castle.MicroKernel.Lifestyle.PerWebRequestLifestyleModule, Castle.Windsor\" />' to the <httpModules> section on your web.config. If you're running IIS7 in Integrated Mode you will need to add it to <modules> section under <system.webServer>",
							typeof(PerWebRequestLifestyleModule).FullName, Environment.NewLine);

					throw new Exception(message);
				}

				var instance = base.Resolve(context);
				current.Items[PerRequestObjectID] = instance;
				PerWebRequestLifestyleModule.RegisterForEviction(this, instance);
			}

			return current.Items[PerRequestObjectID];
		}

		public virtual object Request(CreationContext context)
		{
			object instance;

			using(rwlock.ForWriting())
			{

				if (available.Count != 0)
				{
					instance = available.Pop();

					if (instance == null)
					{
						throw new PoolException("Invalid instance on the pool stack");
					}
				}
				else
				{
					instance = componentActivator.Create(context);

					if (instance == null)
					{
						throw new PoolException("Activator didn't return a valid instance");
					}
				}

				inUse.Add(instance);
			}

			return instance;
		}

        public ILifetimeScope GetScope(CreationContext context)
        {
            if (HttpContext.Current == null)
                throw new InvalidOperationException("HttpContext.Current is null. PerWebSessionLifestyle can only be used in ASP.Net");

            return GetScope(new HttpContextWrapper(HttpContext.Current));
        }

		public override object Resolve(CreationContext context, Burden burden, IReleasePolicy releasePolicy)
		{
			lock (slot)
			{
				var map = (Dictionary<IComponentActivator, object>)Thread.GetData(slot);

				if (map == null)
				{
					map = new Dictionary<IComponentActivator, object>();

					Thread.SetData(slot, map);
				}

				Object instance;

				if (!map.TryGetValue(ComponentActivator, out instance))
				{
					instance = base.Resolve(context, burden, releasePolicy);
					map.Add(ComponentActivator, instance);
					instances.Add(burden);
				}

				return instance;
			}
		}