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

		protected virtual void Track(Burden burden, IReleasePolicy releasePolicy)
		{
			if (burden.RequiresPolicyRelease)
			{
				releasePolicy.Track(burden.Instance, burden);
			}
		}

		public virtual void Track(object instance, Burden burden)
		{
			using(@lock.ForWriting())
			{
				instance2Burden[instance] = burden;
			}
		}

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

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

		}

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

		public override bool ReleaseCore(Burden burden)
		{
			var genericType = ProxyUtil.GetUnproxiedType(burden.Instance);
			var handler = type2SubHandler.GetOrThrow(genericType);

			return handler.Release(burden);
		}

		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 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, Burden burden, IReleasePolicy releasePolicy)
		{
			var current = HttpContext.Current;

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

			var cachedBurden = current.Items[PerRequestObjectID];
			if (cachedBurden != null)
			{
				return cachedBurden;
			}
			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, burden, releasePolicy);
			current.Items[PerRequestObjectID] = burden;
			PerWebRequestLifestyleModule.RegisterForEviction(this, burden);

			return instance;
		}

		public override bool ReleaseCore(Burden burden)
		{
			var genericType = ProxyUtil.GetUnproxiedType(burden.Instance);

			var handler = GetSubHandler(CreationContext.CreateEmpty(), genericType);

			return handler.Release(burden);
		}

		public override void Track(object instance, Burden burden)
		{
			var model = burden.Model;
			if (burden.GraphRequiresDecommission || model.LifestyleType == LifestyleType.Pooled)
			{
				base.Track(instance, burden);
			}
		}

		protected override void Track(Burden burden, IReleasePolicy releasePolicy)
		{
			var track = burden.RequiresPolicyRelease;
			burden.RequiresPolicyRelease = false;
			if (track)
			{
				releasePolicy.Track(burden.Instance, burden);
			}
		}

		public virtual object Create(CreationContext context, Burden burden)
		{
			var instance = InternalCreate(context);
			burden.SetRootInstance(instance);

			onCreation(model, instance);

			return instance;
		}

		public override void Dispose()
		{
			var localInstance = cachedBurden;
			if (localInstance != null)
			{
				localInstance.Release();
				cachedBurden = null;
			}
		}

		public override bool Release(Burden burden)
		{
			if (releaseExtensions == null)
			{
				return base.Release(burden);
			}

			var invocation = new ReleaseInvocation(burden);
			InvokeReleasePipeline(0, invocation);
			return invocation.ReturnValue;
		}

 /// <summary>
 /// Creates the <see cref="ISessionFactory"/> from the configuration
 /// </summary>
 /// <param name="context"></param>
 /// <param name="burden"></param>
 /// <returns></returns>
 public override object Create(CreationContext context, Burden burden)
 {
     //HACK:bugfix SessionFactoryActivator override Create with burden
     RaiseCreatingSessionFactory();
     var configuration = Model.ExtendedProperties[Constants.SessionFactoryConfiguration]
                         as Configuration;
     var f= configuration.BuildSessionFactory();
     burden.SetRootInstance(f);
     //onCreation(model, instance);
     return f;
 }

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

			var factory = configuration.BuildSessionFactory();

			burden.SetRootInstance(factory);
			
			return factory;
		}

		public virtual void Track(object instance, Burden burden)
		{
			using (@lock.ForWriting())
			{
				var oldCount = instance2Burden.Count;
				instance2Burden[instance] = burden;
				if (oldCount < instance2Burden.Count)
				{
					burden.Released += OnInstanceReleased;
				}
			}
		}

		public virtual void Track(object instance, Burden burden)
		{
			rwLock.AcquireWriterLock(Timeout.Infinite);
			try
			{
				instance2Burden[instance] = burden;
			}
			finally
			{
				rwLock.ReleaseWriterLock();
			}
		}