protected override object GetInstance(
IResolvingContext context,
Type concreteType,
IContainer fromContainer)
{
return(_activator.Activate(concreteType, fromContainer, context));
}
protected override IContainer GetOwnerContainer(
IResolvingContext context,
Type concreteType
)
{
return(context.CurrentContainer);
}
public object GetOrCreateInstance(
Type concreteType,
IActivator activator,
IResolvingContext context,
string registrationName)
{
if (!Monitor.TryEnter(_syncRoot, TimeSpan.FromSeconds(5)))
{
throw new InvalidOperationException("Potentially deadlock");
}
try
{
if (HasInstance(concreteType, registrationName))
{
return(GetInstance(concreteType, registrationName));
}
else
{
var instance = activator.Activate(concreteType, _parent, context);;
PutInstance(concreteType, instance, registrationName);
return(instance);
}
}
finally
{
Monitor.Exit(_syncRoot);
}
}
object ResolveImpl(IResolvingContext context)
{
// Grab the container
var container = GetOwnerContainer(context, _concreteType);
var instance = GetInstance(context, _concreteType, container);
// return it
return(instance);
}
public object Activate(Type concreteType, IContainer container, IResolvingContext context)
{
var t = _lambda(container);
if (t is IDisposable)
{
container.AddDisposable((IDisposable)t);
}
return(t);
}
protected override object GetInstance(
IResolvingContext context,
Type concreteType,
IContainer container)
{
return(container.Instances.GetOrCreateInstance(
concreteType,
_activator,
context,
_registrationName));
}
protected override IContainer GetOwnerContainer(
IResolvingContext context,
Type concreteType
)
{
// Notes
// Singleton are stored in the root container
var container = context.KickOffContainer;
while (container.Parent != null)
{
container = (IContainer)container.Parent;
}
return(container);
}
object IResolver.Resolve(IResolvingContext context)
{
// Validate
if (context.ResolvingStack.Contains(_concreteType))
{
throw new CircularDependencyException(_concreteType);
}
// To avoid having circular dependency,
// we keep track the stack
context.ResolvingStack.Add(_concreteType);
try
{
return(ResolveImpl(context));
}
finally { context.ResolvingStack.Remove(_concreteType); }
}
public object Activate(
Type concreteType,
IContainer container,
IResolvingContext context)
{
// Freshly construct the instance
var constructor = concreteType.GetConstructors().First();
var resolvedParameters = constructor
.GetParameters()
.Select(parameterInfo => ProvideParameterValue(container, context, parameterInfo))
.ToArray();
var inst = constructor.Invoke(resolvedParameters);
if (inst is IDisposable)
{
container.AddDisposable((IDisposable)inst);
}
return(inst);
}
protected override IContainer GetOwnerContainer(
IResolvingContext context,
Type concreteType)
{
var container = context.CurrentContainer;
while (container.Parent != null)
{
if (container.Name == _containerName)
{
return(container);
}
else
{
container = (IContainer)container.Parent;
}
}
throw new DependencyException("Failed to find container named: " + _containerName);
}
object ProvideParameterValue(
IContainer container,
IResolvingContext context,
ParameterInfo parameterInfo)
{
// Search to find the first value provider that match this parameter
for (var i = 0; i < _parameterResolvers.Count; i++)
{
if (_parameterResolvers[i].Match(parameterInfo))
{
var inst = _parameterResolvers[i].ValueProvider(parameterInfo, container);
if (inst is IDisposable)
{
container.AddDisposable((IDisposable)container);
}
return(inst);
}
}
// Use the container to resolve the parameter by default
return(container.Resolve(parameterInfo.ParameterType, context));
}
public object Resolve(Type type, IResolvingContext context, string registrationName = null)
{
ThrowIfDisposed();
var registration = FindRegistration(type, registrationName);
context = null == context
? new ResolvingContext {
KickOffContainer = this
}
: context;
context.CurrentContainer = this;
if (null == registration)
{
throw new DependencyException(
"Unregistered type: " + type.ToString() + "; registrationName=" + registrationName,
context.ResolvingStack);
}
else
{
return(registration.Resolver.Resolve(context));
}
}
protected abstract object GetInstance(
IResolvingContext context,
Type concreteType,
IContainer fromContainer
);
protected abstract IContainer GetOwnerContainer(
IResolvingContext context,
Type concreteType
);
