public ICollection <InstanceWrapper> GetInstances(CycleCounter cycleCounter, object[] args)
{
var resultArgs = prePassedArgs.Length > args.Length ? prePassedArgs : args;
switch (scope)
{
case Scope.Transient:
var newInstances = CreateInstances(cycleCounter, resultTypes, resultArgs);
foreach (var newInstance in newInstances)
{
instances.Add(newInstance);
}
return(newInstances);
case Scope.Singleton:
for (var i = 0; i < resultTypes.Length; i++)
{
var resultType = resultTypes[i];
if (i >= instances.Count)
{
instances.Add(CreateInstance(cycleCounter, resultType, args));
}
}
return(instances);
default:
throw new ArgumentException(nameof(scope));
}
}
private void ResolveMethods(CycleCounter cycleCounter, object instance)
{
var type = instance.GetType();
var methods = type.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
var injectableMethods = methods.Where(method => method.GetCustomAttributes(container.injectAttributeType).Any()).ToArray();
foreach (var method in injectableMethods)
{
if (CheckNeedsInjectIntoMember(method, instance))
{
var args = new List <object>();
var parameters = method.GetParameters();
foreach (var parameter in parameters)
{
var values = container.ResolveMultiple(cycleCounter, parameter.ParameterType);
var collected = CollectValue(parameter.ParameterType, values);
var value = collected.Value;
args.Add(value);
}
method.Invoke(instance, args.ToArray());
MarkMemberInjectedInto(method, instance);
}
}
}
internal object[] ResolveMultiple(CycleCounter cycleCounter, Type contractType)
{
var contractIsArray = contractType.IsArray;
var elementType = contractIsArray ? contractType.GetElementType() : contractType;
var instances = ResolveAll(cycleCounter, elementType);
return(instances);
}
private InstanceWrapper[] CreateInstances(CycleCounter cycleCounter, Type[] types, object[] args)
{
var typesLength = types.Length;
var result = new InstanceWrapper[typesLength];
for (var i = 0; i < typesLength; i++)
{
var wrapper = CreateInstance(cycleCounter, types[i], args);
result[i] = wrapper;
}
return(result);
}
internal void InjectIntoInstance(CycleCounter cycleCounter, object instance)
{
if (injectedIntoInstances.Add(instance))
{
cycleCounter.Indent();
ResolveFields(cycleCounter, instance);
ResolveProperties(cycleCounter, instance);
ResolveMethods(cycleCounter, instance);
cycleCounter.Unindent();
}
}
private InstanceWrapper CreateInstance(CycleCounter cycleCounter, Type type, object[] args)
{
cycleCounter.Indent();
var suitableConstructor = GetConstructor(type);
var resolvedArgs = ResolveArgs(cycleCounter, suitableConstructor, args);
var instance = activator.CreateInstance(suitableConstructor, resolvedArgs);
cycleCounter.Unindent();
InjectIntoInstance(cycleCounter, instance);
return(new InstanceWrapper(instance));
}
internal object Resolve(CycleCounter cycleCounter, Type contractType, params object[] args)
{
var contractIsArray = contractType.IsArray;
var elementType = contractIsArray ? contractType.GetElementType() : contractType;
var instances = ResolveAll(cycleCounter, elementType, args);
if (contractIsArray)
{
return(instances);
}
return(instances[0]);
}
internal object[] ResolveAll(CycleCounter cycleCounter, Type contractType, params object[] args)
{
cycleCounter.LogType(contractType);
if (!bindings.TryGetValue(contractType, out var resolver))
{
throw new TypeNotRegisteredException(contractType, $"Resolving graph:{Environment.NewLine}{cycleCounter.Pop()}{Environment.NewLine}{Environment.NewLine}" +
$"Bindings:{Environment.NewLine}{GetBindingsString(bindings)}");
}
var instances = resolver.GetInstances(cycleCounter, args);
InitializeInstances(instances);
return(instances.Select(instance => instance.Value).ToArray());
}
private void ResolveProperties(CycleCounter cycleCounter, object instance)
{
var type = instance.GetType();
var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
var injectableProperties = properties.Where(property => property.GetCustomAttributes(container.injectAttributeType).Any()).ToArray();
foreach (var property in injectableProperties)
{
if (CheckNeedsInjectIntoMember(property, instance))
{
var values = container.ResolveMultiple(cycleCounter, property.PropertyType);
var collected = CollectValue(property.PropertyType, values);
var value = collected.Value;
property.SetValue(instance, value);
MarkMemberInjectedInto(property, instance);
}
}
}
private void ResolveFields(CycleCounter cycleCounter, object instance)
{
var type = instance.GetType();
var fields = type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
var injectableFields = fields.Where(field => field.GetCustomAttributes(container.injectAttributeType).Any()).ToArray();
foreach (var field in injectableFields)
{
if (CheckNeedsInjectIntoMember(field, instance))
{
var values = container.ResolveMultiple(cycleCounter, field.FieldType);
var collected = CollectValue(field.FieldType, values);
var value = collected.Value;
field.SetValue(instance, value);
MarkMemberInjectedInto(field, instance);
}
}
}
private object[] ResolveArgs(CycleCounter cycleCounter, ConstructorInfo constructorInfo, object[] args)
{
var parameters = constructorInfo.GetParameters();
if (parameters.Length == 0)
{
return(new object[0]);
}
var result = new object[parameters.Length];
for (var i = 0; i < parameters.Length; i++)
{
var parameterInfo = parameters[i];
var parameterType = parameterInfo.ParameterType;
var lessArgs = i >= args.Length;
if (lessArgs)
{
result[i] = container.Resolve(cycleCounter, parameterType);
}
else
{
var arg = args[i];
if (CheckAssignable(parameterType, arg.GetType()))
{
result[i] = arg;
}
else
{
result[i] = container.Resolve(parameterType);
}
}
result = argConverter.Convert(parameterType, result);
}
return(result);
}
internal object Resolve(CycleCounter cycleCounter, Type contractType)
{
return(Resolve(cycleCounter, contractType, new object[0]));
}
