public IActivator ResolveActivator(IResolutionServices services, ServiceEntry entry) { if ((services.Flags & LookupFlags.ThrowIfUnable) == LookupFlags.ThrowIfUnable) { throw new PendingDependencyException(services.DependencyGraphTracker.BuildProgressMessage(entry)); } return null; }
public override bool CanActivate(IResolutionServices services) { if (_activation == null) { return base.CanActivate(services); } return true; }
public IActivator ResolveActivator(IResolutionServices services, ServiceEntry entry) { if (entry.ServiceType.IsInterface) { return(services.ActivatorFactory.CreateStaticActivator(entry, Get(entry.ServiceType))); } return(null); }
public IActivator ResolveActivator(IResolutionServices services, ServiceEntry entry) { if (!_container.CanResolve(entry.ServiceType)) { return null; } return new ParentContainerActivator(_container, entry); }
public IActivator ResolveActivator(IResolutionServices services, ServiceEntry entry) { object value = services.Overrides.LookupOverride(entry); if (value == null) { return null; } return services.ActivatorFactory.CreateStaticActivator(entry, value); }
public Activation Activate(IResolutionServices services) { Activation activation = _target.Activate(services); if (_entry.HasPropertySettings()) { _entry.PropertySettings.Apply(activation.Instance); } return activation; }
public override void Deactivate(IResolutionServices services, object instance) { if (_activation == null) { throw new YouFoundABugException("You managed to re-release something?"); } _activation = null; base.Deactivate(services, instance); }
public ServiceEntry ToServiceEntry(IResolutionServices services) { ServiceEntry entry = _serviceGraph.Lookup(_type, services.Flags); if (entry != null) { return entry; } return _serviceEntryFactory.CreateServiceEntry(_dependency); }
public virtual ServiceEntry ToServiceEntry(IResolutionServices services) { ServiceEntry entry = _serviceGraph.Lookup(_type, services.Flags); if (entry != null) { return entry; } return _serviceEntryFactory.CreateServiceEntry(_type, _type, LifestyleType.Override); }
public void DeactivateAll(IResolutionServices services) { foreach (RememberedActivation rememberedActivation in _trackingPolicy.RetrieveAndForgetAll()) { Deactivation deactivation = rememberedActivation.ToDeactivation(); _listenerInvoker.OnDeactivation(rememberedActivation.ResolvedEntry, deactivation); rememberedActivation.Deactivate(services); } }
public void Deactivate(IResolutionServices services, object instance) { Deactivation deactivation = new Deactivation(instance); RememberedActivation rememberedActivation = _trackingPolicy.RetrieveAndForget(instance); if (rememberedActivation != null) { _listenerInvoker.OnDeactivation(rememberedActivation.ResolvedEntry, deactivation); rememberedActivation.Deactivate(services); } }
public Activation Activate(IResolutionServices services) { if (_selectedCandidate == null) { throw new YouFoundABugException("How can you try and Activate something if it can't be activated: " + _entry); } object[] parameters = ResolveConstructorDependencies(services); object instance = _objectFactory.CreateObject(_selectedCandidate.Candidate, parameters); return new Activation(_entry, instance, true); }
public Activation Activate(IResolutionServices services) { Activation activation = _activator.Activate(services); activation.MakeFullyActivated(_activator); if (activation.IsBrandNew) { _objectInstances.Remember(this, activation); } return activation; }
public override Activation Activate(IResolutionServices services) { if (_activation == null) { Activation firstActivation = base.Activate(services); _activation = new Activation(firstActivation); return firstActivation; } return _activation; }
protected virtual object[] ResolveConstructorDependencies(IResolutionServices services) { List<object> parameters = new List<object>(); foreach (ResolvedServiceEntry dependency in _selectedCandidate.ResolvedDependencies) { Activation activation = dependency.Activate(services); activation.AssertIsFullyActivated(); parameters.Add(activation.Instance); } return parameters.ToArray(); }
private static void CreateActivatorForEntryIfNecessary(IResolutionServices services, ServiceEntry entry) { if (!services.ActivatorStore.HasActivator(entry)) { entry.Lock.UpgradeToWriterLock(); if (services.ActivatorStore.HasActivator(entry)) { return; } ILifestyle lifestyle = services.LifestyleFactory.CreateLifestyle(entry); services.ActivatorStore.AddActivator(entry, lifestyle); } }
public virtual IActivator ResolveActivator(IResolutionServices services, ServiceEntry entry) { if (!services.ActivatorStore.HasActivator(entry)) { return null; } IActivator activator = services.ActivatorStore.ResolveActivator(entry); if (activator.CanActivate(services)) { return activator; } throw new ServiceResolutionException("Unable to activate: " + entry); }
public bool CanActivate(IResolutionServices services) { using (services.DependencyGraphTracker.Push(_entry)) { if (!TypeCanBeActivated()) { return false; } /* I don't care if we do this multiple times as we race to get it down for now... */ if (_selectedCandidate == null) { _selectedCandidate = ResolveConstructorCandidate(services); } return _selectedCandidate != null; } }
protected virtual ResolvedConstructorCandidate ResolveConstructorCandidate(IResolutionServices services) { List<ResolvedServiceEntry> resolved = new List<ResolvedServiceEntry>(); ConstructorCandidate candidate = _serviceDependencyInspector.SelectConstructor(_entry.ConcreteType); foreach (ServiceDependency dependency in candidate.Dependencies) { IResolvableType resolvableType = services.ResolvableTypeMap.FindResolvableType(dependency); ResolvedServiceEntry dependencyEntry = _serviceEntryResolver.ResolveEntry(services, resolvableType); if (dependencyEntry == null) { return null; } resolved.Add(dependencyEntry); } return new ResolvedConstructorCandidate(candidate, resolved); }
public Activation Activate(IResolutionServices services) { Activation activation = _target.Activate(services); ServiceEntry entry = activation.Entry; if (!entry.HasInterceptorsApplied) { throw new ServiceContainerException("Entry should have interceptors: " + entry); } try { object proxied = _proxyGenerator.CreateInterfaceProxyWithTarget(entry.ServiceType, activation.Instance, ProxyGenerationOptions.Default, FindInterceptors(entry)); return new Activation(activation.Entry, proxied); } catch (Exception error) { throw new DynamicProxyException("Error activating with DynamicProxy", error); } }
public ResolvedServiceEntry ResolveEntry(IResolutionServices services, IResolvableType resolvableType) { ServiceEntry entry = resolvableType.ToServiceEntry(services); using (entry.Lock.AcquireReaderLock()) { /* Never want to auto create activator for the entry we created above. */ if (entry.CanHaveActivator) { CreateActivatorForEntryIfNecessary(services, entry); } } IActivator activator = _activatorResolver.ResolveActivator(services, entry); if (activator == null) { return null; } return new ResolvedServiceEntry(entry, activator, services.ObjectInstances); }
public IActivator ResolveActivator(IResolutionServices services, ServiceEntry entry) { if (FactoryHelper.IsFactoryType(entry.ServiceType)) { return null; } Type factoryType = FactoryHelper.CreateFactoryType(entry.ServiceType); if (!_container.CanResolve(factoryType)) { return null; } lock (_lock) { if (services.ActivatorStore.HasActivator(entry)) { return services.ActivatorStore.ResolveActivator(entry); } IActivator activator = new FactoriesActivator(_container, entry); services.ActivatorStore.AddActivator(entry, activator); services.ServiceGraph.Add(entry); return activator; } }
public virtual bool CanActivate(IResolutionServices services) { return _defaultActivator.CanActivate(services); }
public void Deactivate(IResolutionServices services, object instance) { _container.Deactivate(instance); }
public bool CanActivate(IResolutionServices services) { return _container.CanResolve(_entry.ServiceType); }
public Activation Activate(IResolutionServices services) { /* TODO: Pass the overrides down somehow? */ object instance = _container.Resolve.Object(_entry.ServiceType); return new Activation(_entry, instance, false); }
public void Deactivate(IResolutionServices services, object instance) { throw new ServiceContainerException("Releasing staticly registered instances is weird!"); }
public Activation Activate(IResolutionServices services) { return _activation; }
public virtual void Deactivate(IResolutionServices services, object instance) { _defaultActivator.Deactivate(services, instance); }
public void Deactivate(IResolutionServices services, object instance) { ChooseLifestyle().Deactivate(services, instance); }
public bool CanActivate(IResolutionServices services) { return true; }