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