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; }
public virtual object Resolve(CreationContext context, Burden burden, IReleasePolicy releasePolicy) { var instance = CreateInstance(context, burden); Track(burden, releasePolicy); return instance; }
protected IHandler GetSubHandler(CreationContext context, Type genericType) { IHandler handler; if (type2SubHandler.TryGetValue(genericType, out handler)) { return handler; } lock (type2SubHandler) { if (type2SubHandler.TryGetValue(genericType, out handler)) { return handler; } // TODO: we should probably match the requested type to existing services and close them over its generic arguments var service = context.RequestedType; var newModel = Kernel.ComponentModelBuilder.BuildModel( ComponentModel.Name, new[] { 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]; }
/// <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 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(); } } }
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 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)); }
protected override object ResolveCore(CreationContext context, bool track, bool instanceRequired) { Type implType; try { implType = ComponentModel.Implementation.MakeGenericType(context.GenericArguments); } catch (ArgumentException) { // may throw in some cases when impl has generic constraints that service hasn't if(instanceRequired) { throw; } return null; } var handler = GetSubHandler(context, implType); // so the generic version wouldn't be considered as well using(context.EnterResolutionContext(this, false)) { return handler.Resolve(context); } }
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 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 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 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) { // detect circular dependencies if (IsBeingResolvedInContext(context)) return false; foreach (var dependency in DependenciesByService.Values.ToArray()) { if(context.HasAdditionalParameters && MatchParameterToDependency(context.AdditionalParameters, dependency)) { continue; } // a self-dependency is not allowed var handler = Kernel.GetHandler(dependency.TargetType); if (handler == this) { return false; } if(handler == null) { // ask the kernel if (Kernel.LazyLoadComponentByType(dependency.DependencyKey, dependency.TargetType, context.AdditionalParameters) == false) { return false; } } } if (context.HasAdditionalParameters == false) { return DependenciesByKey.Count == 0; } return DependenciesByKey.Values.All(d => MatchParameterToDependency(context.AdditionalParameters, d)); }
public override object Resolve(CreationContext context, IReleasePolicy releasePolicy) { lock (slot) { var map = (Dictionary<IComponentActivator, Burden>)Thread.GetData(slot); if (map == null) { map = new Dictionary<IComponentActivator, Burden>(); Thread.SetData(slot, map); } Burden burden; if (!map.TryGetValue(ComponentActivator, out burden)) { burden = base.CreateInstance(context, true); map.Add(ComponentActivator, burden); instances.Add(burden); Track(burden, releasePolicy); } return burden.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 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]; }
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> /// 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 IScopeCache GetScopeCache(CreationContext context, bool required = true) { if (selector == null) { return GetScopeExplicit(required); } return GetScopeImplicit(required, context); }
protected virtual Burden CreateInstance(CreationContext context, bool trackedExternally) { var burden = context.CreateBurden(ComponentActivator, trackedExternally); var instance = componentActivator.Create(context, burden); Debug.Assert(ReferenceEquals(instance, burden.Instance)); return burden; }
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency) { return dependency.TargetType != null && dependency.TargetType.IsArray && kernel.HasComponent(dependency.TargetType.GetElementType()); }
public override object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency) { var items = base.Resolve(context, contextHandlerResolver, model, dependency); var listType = BuildListType(dependency); return listType.CreateInstance<object>(items); }
public virtual object Create(CreationContext context) { var instance = InternalCreate(context); onCreation(model, instance); return instance; }
protected virtual object Instantiate(CreationContext context) { var candidate = SelectEligibleConstructor(context); var arguments = CreateConstructorArguments(candidate, context); return CreateInstance(context, candidate, arguments); }
public virtual bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency) { return(HasAdditionalArguments && (CanResolveByKey(dependency) || CanResolveByType(dependency))); }