private ParameterInfoCache[] GetParameterInfoCache(ParameterInfo[] parameters)
{
if (parameters == null || parameters.Length == 0)
{
return(null);
}
ParameterInfoCache[] parametersCache = new ParameterInfoCache[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
ParameterInfo parameterInfo = parameters[i];
object[] injectAttributes = parameterInfo.GetCustomAttributes(typeof(InjectAttribute), true);
InjectAttribute injectAttribute = null;
if (injectAttributes.Length > 0)
{
injectAttribute = (InjectAttribute)injectAttributes[0];
}
parametersCache[i] = new ParameterInfoCache(parameters[i], injectAttribute);
}
return(parametersCache);
}
private void InjectMethod(IContainer container, IInjectContext parentContext, Type type, object obj, MethodInfoCache method)
{
ParameterInfoCache[] parameters = method.Parameters;
if (parameters == null || parameters.Length == 0)
{
method.MethodInfo.Invoke(obj, null);
return;
}
object[] paramObjects = new object[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
ParameterInfoCache parameter = parameters[i];
ParameterInfo parameterInfo = parameter.ParameterInfo;
// Can we resolve this?
if (container.HasBindingFor(parameterInfo.ParameterType))
{
// Prevent recursive / circular dependency...
if (parameterInfo.ParameterType.IsAssignableFrom(type) || _currentlyResolvingTypes.Contains(parameterInfo.ParameterType))
{
LogHandler?.Invoke("Injector: Circular dependency detected in Method {0}.{1}, parameter index: {2}", type, method.MethodInfo.Name, i);
paramObjects[i] = null;
}
else
{
InjectContext injectContext = new InjectContext(container, method.DeclaringType, parentContext);
Type parameterType = parameterInfo.ParameterType;
object paramInstance = container.ResolveWithCategory(parameterType, parameter.InjectAttribute?.Category, injectContext);
paramObjects[i] = paramInstance;
}
}
else
{
LogHandler?.Invoke("Injector: {0} - Type is not bound in the container, assigning as null {1}, method {2}, parameter index: {2}", type, parameterInfo.ParameterType, method.MethodInfo.Name, i);
paramObjects[i] = null;
}
}
method.MethodInfo.Invoke(obj, paramObjects.ToArray());
}
private object ExecuteConstructor(IContainer container, IInjectContext parentContext, ConstructorInfoCache constructor, Type type, params object[] addDependencies)
{
ParameterInfoCache[] parameters = constructor.Parameters;
if (parameters == null || parameters.Length == 0)
{
return(constructor.ConstructorInfo.Invoke(null));
}
// Resolve parameters
object[] paramObjects = new object[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
ParameterInfoCache parameter = parameters[i];
ParameterInfo parameterInfo = parameter.ParameterInfo;
// Can we resolve this?
if (container.HasBindingFor(parameterInfo.ParameterType))
{
bool isCircularDependency = false;
foreach (Type resolvingType in _currentlyResolvingTypes)
{
if (parameterInfo.ParameterType.IsAssignableFrom(resolvingType))
{
isCircularDependency = true;
}
}
// Prevent recursive / circular dependency...
if (isCircularDependency)
{
LogHandler?.Invoke("Injector: Circular dependency detected in Type {0} parameter index: {1}", type, i);
paramObjects[i] = null;
}
else
{
InjectContext injectContext = new InjectContext(container, constructor.DeclaringType, parentContext);
object paramInstance = container.ResolveWithCategory(parameterInfo.ParameterType, parameters[i].InjectAttribute?.Category, injectContext);
paramObjects[i] = paramInstance;
}
}
else
{
bool hasAdditionalDependency = false;
// Check additional dependencies...
foreach (object dependency in addDependencies)
{
if (parameterInfo.ParameterType.IsInstanceOfType(dependency))
{
hasAdditionalDependency = true;
paramObjects[i] = dependency;
break;
}
}
if (!hasAdditionalDependency)
{
LogHandler?.Invoke("Injector: {0} - Type is not bound in the container, assigning as null {1}, parameter index: {2}", type, parameterInfo.ParameterType, i);
paramObjects[i] = null;
}
}
}
// Invoke constructor...
object instance = constructor.ConstructorInfo.Invoke(paramObjects);
return(instance);
}