internal ServiceDependency InstantiateDependency(ParameterInfo formalParameter, ContainerService.Builder builder)
{
ValueWithType actualArgument;
if (builder.Arguments != null && builder.Arguments.TryGet(formalParameter.Name, out actualArgument))
{
return(containerContext.Constant(formalParameter, actualArgument.value));
}
var parameters = builder.Configuration.ParametersSource;
object actualParameter;
if (parameters != null && parameters.TryGet(formalParameter.Name, formalParameter.ParameterType, out actualParameter))
{
return(containerContext.Constant(formalParameter, actualParameter));
}
var dependencyConfiguration = builder.Configuration.GetOrNull(formalParameter);
Type implementationType = null;
if (dependencyConfiguration != null)
{
if (dependencyConfiguration.ValueAssigned)
{
return(containerContext.Constant(formalParameter, dependencyConfiguration.Value));
}
if (dependencyConfiguration.Factory != null)
{
var dependencyBuilder = new ContainerService.Builder(new ServiceName(formalParameter.ParameterType))
{
Context = builder.Context,
DependencyName = formalParameter.Name
};
builder.Context.Stack.Add(dependencyBuilder);
dependencyBuilder.CreateInstanceBy(CallTarget.F(dependencyConfiguration.Factory), true);
builder.Context.Stack.RemoveLast();
return(dependencyBuilder.GetService().AsDependency(containerContext, formalParameter.Name, false));
}
implementationType = dependencyConfiguration.ImplementationType;
}
implementationType = implementationType ?? formalParameter.ParameterType;
FromResourceAttribute resourceAttribute;
if (implementationType == typeof(Stream) && formalParameter.TryGetCustomAttribute(out resourceAttribute))
{
var resourceStream = builder.Type.Assembly.GetManifestResourceStream(builder.Type, resourceAttribute.Name);
if (resourceStream == null)
{
return(containerContext.Error(null, formalParameter.Name,
"can't find resource [{0}] in namespace of [{1}], assembly [{2}]",
resourceAttribute.Name, builder.Type, builder.Type.Assembly.GetName().Name));
}
return(containerContext.Resource(formalParameter, resourceAttribute.Name, resourceStream));
}
var dependencyName = ServiceName.Parse(implementationType.UnwrapEnumerable(),
InternalHelpers.ParseContracts(formalParameter));
if (dependencyName.Type.IsSimpleType())
{
if (!formalParameter.HasDefaultValue)
{
return(containerContext.Error(null, formalParameter.Name,
"parameter [{0}] of service [{1}] is not configured",
formalParameter.Name, builder.Type.FormatName()));
}
return(containerContext.Constant(formalParameter, formalParameter.DefaultValue));
}
var resultService = ResolveCore(dependencyName, false, null, builder.Context);
if (resultService.Status.IsBad())
{
return(containerContext.ServiceError(resultService));
}
var isEnumerable = dependencyName.Type != implementationType;
if (isEnumerable)
{
return(containerContext.Service(resultService, resultService.GetAllValues()));
}
if (resultService.Status == ServiceStatus.NotResolved)
{
if (formalParameter.HasDefaultValue)
{
return(containerContext.Service(resultService, formalParameter.DefaultValue));
}
if (formalParameter.IsDefined <OptionalAttribute>() || formalParameter.IsDefined("CanBeNullAttribute"))
{
return(containerContext.Service(resultService, null));
}
return(containerContext.NotResolved(resultService));
}
return(resultService.AsDependency(containerContext, null, false));
}
private void InstantiateImplementation(ContainerService.Builder builder)
{
if (builder.DontUse())
{
builder.SetComment("DontUse");
return;
}
var result = FactoryCreator.TryCreate(builder) ?? LazyCreator.TryCreate(builder);
if (result != null)
{
builder.AddInstance(result, true, false);
return;
}
if (NestedFactoryCreator.TryCreate(builder))
{
return;
}
if (CtorFactoryCreator.TryCreate(builder))
{
return;
}
if (builder.Type.IsDelegate())
{
builder.SetError(string.Format("can't create delegate [{0}]", builder.Type.FormatName()));
return;
}
var constructor = builder.Type.GetConstructor();
if (!constructor.isOk)
{
builder.SetError(constructor.errorMessage);
return;
}
var formalParameters = constructor.value.GetParameters();
var actualArguments = new object[formalParameters.Length];
var hasServiceNameParameters = false;
for (var i = 0; i < formalParameters.Length; i++)
{
var formalParameter = formalParameters[i];
if (formalParameter.ParameterType == typeof(ServiceName))
{
hasServiceNameParameters = true;
continue;
}
var dependency = InstantiateDependency(formalParameter, builder).CastTo(formalParameter.ParameterType);
builder.AddDependency(dependency, false);
if (dependency.ContainerService != null)
{
builder.UnionUsedContracts(dependency.ContainerService);
}
if (builder.Status != ServiceStatus.Ok && !builder.Context.AnalizeDependenciesOnly)
{
return;
}
actualArguments[i] = dependency.Value;
}
foreach (var d in builder.Configuration.ImplicitDependencies)
{
var dependency = ResolveCore(ServiceName.Parse(d.Type, d.Contracts), false, null, builder.Context)
.AsDependency(containerContext, null, false);
dependency.Comment = "implicit";
builder.AddDependency(dependency, false);
if (dependency.ContainerService != null)
{
builder.UnionUsedContracts(dependency.ContainerService);
}
if (builder.Status != ServiceStatus.Ok)
{
return;
}
}
builder.EndResolveDependencies();
if (builder.Context.AnalizeDependenciesOnly)
{
return;
}
var dependenciesResolvedByArguments = builder.Arguments == null ? null : builder.Arguments.GetUsed();
List <string> unusedConfigurationKeys = null;
foreach (var k in builder.Configuration.GetUnusedDependencyKeys())
{
var resolvedByArguments = dependenciesResolvedByArguments != null &&
k.name != null &&
dependenciesResolvedByArguments.Contains(k.name);
if (resolvedByArguments)
{
continue;
}
if (unusedConfigurationKeys == null)
{
unusedConfigurationKeys = new List <string>();
}
unusedConfigurationKeys.Add(k.ToString());
}
if (unusedConfigurationKeys != null)
{
builder.SetError(string.Format("unused dependency configurations [{0}]", unusedConfigurationKeys.JoinStrings(",")));
return;
}
if (hasServiceNameParameters)
{
for (var i = 0; i < formalParameters.Length; i++)
{
if (formalParameters[i].ParameterType == typeof(ServiceName))
{
actualArguments[i] = builder.GetFinalName();
}
}
}
if (builder.CreateNew || builder.DeclaredContracts.Length == builder.FinalUsedContracts.Length)
{
builder.CreateInstanceBy(CallTarget.M(constructor.value, null, actualArguments), true);
if (builder.CreateNew && builder.Arguments == null)
{
var compiledConstructor = constructor.value.Compile();
factoryCache.TryAdd(builder.GetFinalName(), () =>
{
var instance = compiledConstructor(null, actualArguments);
var component = instance as IInitializable;
if (component != null)
{
component.Initialize();
}
return(instance);
});
}
return;
}
var serviceForUsedContractsId = instanceCache.GetOrAdd(builder.GetFinalName(), createId);
var acquireResult = serviceForUsedContractsId.AcquireInstantiateLock();
if (acquireResult.acquired)
{
builder.CreateInstanceBy(CallTarget.M(constructor.value, null, actualArguments), true);
serviceForUsedContractsId.ReleaseInstantiateLock(builder.Context.AnalizeDependenciesOnly
? null
: builder.GetService());
}
else
{
builder.Reuse(acquireResult.alreadyConstructedService);
}
}
internal ContainerService ResolveCore(ServiceName name, bool createNew, IObjectAccessor arguments, ResolutionContext context)
{
var pushedContracts = context.Contracts.Push(name.Contracts);
var declaredName = new ServiceName(name.Type, context.Contracts.Snapshot());
if (context.HasCycle(declaredName))
{
var message = string.Format("cyclic dependency for service [{0}], stack\r\n{1}",
declaredName.Type.FormatName(), context.FormatStack() + "\r\n\t" + declaredName);
context.Contracts.RemoveLast(pushedContracts.pushedContractsCount);
return ContainerService.Error(declaredName, message);
}
if (!pushedContracts.isOk)
{
const string messageFormat = "contract [{0}] already declared, stack\r\n{1}";
var message = string.Format(messageFormat, pushedContracts.duplicatedContractName,
context.FormatStack() + "\r\n\t" + name);
context.Contracts.RemoveLast(pushedContracts.pushedContractsCount);
return ContainerService.Error(name, message);
}
context.ConstructingServices.Add(declaredName);
ServiceConfiguration configuration = null;
Exception configurationException = null;
try
{
configuration = GetConfiguration(declaredName.Type, context);
}
catch (Exception e)
{
configurationException = e;
}
var actualName = configuration != null && configuration.FactoryDependsOnTarget && context.Stack.Count > 0
? declaredName.AddContracts(context.TopBuilder.Type.FormatName())
: declaredName;
ContainerServiceId id = null;
if (!createNew)
{
id = instanceCache.GetOrAdd(actualName, createId);
var acquireResult = id.AcquireInstantiateLock();
if (!acquireResult.acquired)
{
context.ConstructingServices.Remove(declaredName);
context.Contracts.RemoveLast(pushedContracts.pushedContractsCount);
return acquireResult.alreadyConstructedService;
}
}
var builder = new ContainerService.Builder(actualName);
context.Stack.Add(builder);
builder.Context = context;
builder.DeclaredContracts = actualName.Contracts;
if (configuration == null)
builder.SetError(configurationException);
else
{
builder.SetConfiguration(configuration);
builder.ExpandedUnions = context.Contracts.TryExpandUnions(Configuration);
if (builder.ExpandedUnions.HasValue)
{
var poppedContracts = context.Contracts.PopMany(builder.ExpandedUnions.Value.contracts.Length);
foreach (var c in builder.ExpandedUnions.Value.contracts.CartesianProduct())
{
var childService = ResolveCore(new ServiceName(name.Type, c), createNew, arguments, context);
builder.LinkTo(containerContext, childService, null);
if (builder.Status.IsBad())
break;
}
context.Contracts.PushNoCheck(poppedContracts);
}
else
{
builder.CreateNew = createNew;
builder.Arguments = arguments;
Instantiate(builder);
}
}
context.ConstructingServices.Remove(declaredName);
context.Contracts.RemoveLast(pushedContracts.pushedContractsCount);
context.Stack.RemoveLast();
var result = builder.GetService();
if (id != null)
id.ReleaseInstantiateLock(builder.Context.AnalizeDependenciesOnly ? null : result);
return result;
}
internal ContainerService ResolveCore(ServiceName name, bool createNew, IObjectAccessor arguments, ResolutionContext context)
{
var pushedContracts = context.Contracts.Push(name.Contracts);
var declaredName = new ServiceName(name.Type, context.Contracts.Snapshot());
if (context.HasCycle(declaredName))
{
var message = string.Format("cyclic dependency for service [{0}], stack\r\n{1}",
declaredName.Type.FormatName(), context.FormatStack() + "\r\n\t" + declaredName);
context.Contracts.RemoveLast(pushedContracts.pushedContractsCount);
return(ContainerService.Error(declaredName, message));
}
if (!pushedContracts.isOk)
{
const string messageFormat = "contract [{0}] already declared, stack\r\n{1}";
var message = string.Format(messageFormat, pushedContracts.duplicatedContractName,
context.FormatStack() + "\r\n\t" + name);
context.Contracts.RemoveLast(pushedContracts.pushedContractsCount);
return(ContainerService.Error(name, message));
}
context.ConstructingServices.Add(declaredName);
ServiceConfiguration configuration = null;
Exception configurationException = null;
try
{
configuration = GetConfiguration(declaredName.Type, context);
}
catch (Exception e)
{
configurationException = e;
}
var actualName = configuration != null && configuration.FactoryDependsOnTarget && context.Stack.Count > 0
? declaredName.AddContracts(context.TopBuilder.Type.FormatName())
: declaredName;
ContainerServiceId id = null;
if (!createNew)
{
id = instanceCache.GetOrAdd(actualName, createId);
var acquireResult = id.AcquireInstantiateLock();
if (!acquireResult.acquired)
{
context.ConstructingServices.Remove(declaredName);
context.Contracts.RemoveLast(pushedContracts.pushedContractsCount);
return(acquireResult.alreadyConstructedService);
}
}
var builder = new ContainerService.Builder(actualName);
context.Stack.Add(builder);
builder.Context = context;
builder.DeclaredContracts = actualName.Contracts;
if (configuration == null)
{
builder.SetError(configurationException);
}
else
{
builder.SetConfiguration(configuration);
builder.ExpandedUnions = context.Contracts.TryExpandUnions(Configuration);
if (builder.ExpandedUnions.HasValue)
{
var poppedContracts = context.Contracts.PopMany(builder.ExpandedUnions.Value.contracts.Length);
foreach (var c in builder.ExpandedUnions.Value.contracts.CartesianProduct())
{
var childService = ResolveCore(new ServiceName(name.Type, c), createNew, arguments, context);
builder.LinkTo(containerContext, childService, null);
if (builder.Status.IsBad())
{
break;
}
}
context.Contracts.PushNoCheck(poppedContracts);
}
else
{
builder.CreateNew = createNew;
builder.Arguments = arguments;
Instantiate(builder);
}
}
context.ConstructingServices.Remove(declaredName);
context.Contracts.RemoveLast(pushedContracts.pushedContractsCount);
context.Stack.RemoveLast();
var result = builder.GetService();
if (id != null)
{
id.ReleaseInstantiateLock(builder.Context.AnalizeDependenciesOnly ? null : result);
}
return(result);
}
internal ServiceDependency InstantiateDependency(ParameterInfo formalParameter, ContainerService.Builder builder)
{
ValueWithType actualArgument;
if (builder.Arguments != null && builder.Arguments.TryGet(formalParameter.Name, out actualArgument))
return containerContext.Constant(formalParameter, actualArgument.value);
var parameters = builder.Configuration.ParametersSource;
object actualParameter;
if (parameters != null && parameters.TryGet(formalParameter.Name, formalParameter.ParameterType, out actualParameter))
return containerContext.Constant(formalParameter, actualParameter);
var dependencyConfiguration = builder.Configuration.GetOrNull(formalParameter);
Type implementationType = null;
if (dependencyConfiguration != null)
{
if (dependencyConfiguration.ValueAssigned)
return containerContext.Constant(formalParameter, dependencyConfiguration.Value);
if (dependencyConfiguration.Factory != null)
{
var dependencyBuilder = new ContainerService.Builder(new ServiceName(formalParameter.ParameterType))
{
Context = builder.Context,
DependencyName = formalParameter.Name
};
builder.Context.Stack.Add(dependencyBuilder);
dependencyBuilder.CreateInstanceBy(CallTarget.F(dependencyConfiguration.Factory), true);
builder.Context.Stack.RemoveLast();
return dependencyBuilder.GetService().AsDependency(containerContext, formalParameter.Name, false);
}
implementationType = dependencyConfiguration.ImplementationType;
}
implementationType = implementationType ?? formalParameter.ParameterType;
FromResourceAttribute resourceAttribute;
if (implementationType == typeof (Stream) && formalParameter.TryGetCustomAttribute(out resourceAttribute))
{
var resourceStream = builder.Type.Assembly.GetManifestResourceStream(builder.Type, resourceAttribute.Name);
if (resourceStream == null)
return containerContext.Error(null, formalParameter.Name,
"can't find resource [{0}] in namespace of [{1}], assembly [{2}]",
resourceAttribute.Name, builder.Type, builder.Type.Assembly.GetName().Name);
return containerContext.Resource(formalParameter, resourceAttribute.Name, resourceStream);
}
var dependencyName = ServiceName.Parse(implementationType.UnwrapEnumerable(),
InternalHelpers.ParseContracts(formalParameter));
if (dependencyName.Type.IsSimpleType())
{
if (!formalParameter.HasDefaultValue)
return containerContext.Error(null, formalParameter.Name,
"parameter [{0}] of service [{1}] is not configured",
formalParameter.Name, builder.Type.FormatName());
return containerContext.Constant(formalParameter, formalParameter.DefaultValue);
}
var resultService = ResolveCore(dependencyName, false, null, builder.Context);
if (resultService.Status.IsBad())
return containerContext.ServiceError(resultService);
var isEnumerable = dependencyName.Type != implementationType;
if (isEnumerable)
return containerContext.Service(resultService, resultService.GetAllValues());
if (resultService.Status == ServiceStatus.NotResolved)
{
if (formalParameter.HasDefaultValue)
return containerContext.Service(resultService, formalParameter.DefaultValue);
if (formalParameter.IsDefined<OptionalAttribute>() || formalParameter.IsDefined("CanBeNullAttribute"))
return containerContext.Service(resultService, null);
return containerContext.NotResolved(resultService);
}
return resultService.AsDependency(containerContext, null, false);
}
