public override void Inject(object instance)
{
//PublicField Injection
var fieldsToAutoInject = this._type.GetMembers().Where(field => Attribute.IsDefined(field, typeof(AutoInjectAttribute)) && field.MemberType == MemberTypes.Field);
foreach (var field in fieldsToAutoInject)
{
FieldInfo fieldInfo = (FieldInfo)field;
string dependencyId = GetMemberInjectDependency(fieldInfo) ?? fieldInfo.FieldType.GetDependencyId();
if (this.Container.ContainsDependency(dependencyId))
{
IDependencyHolder primaryDepHolder = this.Container.GetDependencyMap(dependencyId).PrimaryDependencyHolder;
if (primaryDepHolder == null)
{
throw new PrimaryOrPreferredTargetDependencyNotFound("Source dependency: " + dependencyId);
}
object memberValue = primaryDepHolder.GetInstance(GetMemberInjectValues(fieldInfo));
fieldInfo.SetValue(instance, memberValue);
}
else
{
string errMsg = string.Format("{0} dependency not found or is not attributed as Injectable while auto injecting the field '{1}' of dependency: {2}", dependencyId, fieldInfo.Name, this._type.GetDependencyId());
throw new NonInjectableTypeException(errMsg);
}
}
this.InjectNext(instance);
}
public virtual T InjectByName <T>(string targetTypeName, params object[] args)
{
string dependencyId = typeof(T).GetDependencyId();
var targetDependency = this.Container.SearchDependency(targetTypeName);
if (targetDependency.Count == 1)
{
IDependencyHolder primaryDependencyHolder = targetDependency[0].PrimaryDependencyHolder;
if (primaryDependencyHolder != null)
{
return((T)primaryDependencyHolder.GetInstance(args));
}
}
else
{
if (targetDependency.Count == 0)
{
throw new NonInjectableTypeException(targetTypeName + " dependency not found or is not attributed as Injectable");
}
else
{
throw new InjectionAmbiguityException(targetTypeName + " dependency has multiple matching type, prefix the namespace(s) to enforce the strict the search");
}
}
return(default(T));
}
public virtual TSource Inject <TSource, TTarget>(params object[] args)
{
string sourceDependencyId = typeof(TSource).GetDependencyId();
string targetDependencyId = typeof(TTarget).GetDependencyId();
if (sourceDependencyId == targetDependencyId)
{
return(Inject <TSource>(args));
}
if (this.Container.ContainsDependency(sourceDependencyId))
{
//Todo: For Interface/Abs Class dont have any imple class marked with Injectable, PrimaryDependencyHolder is null - Need to handle
IDependencyHolder primaryDependencyHolder = this.Container.GetDependencyMap(sourceDependencyId).PrimaryDependencyHolder;
if (primaryDependencyHolder != null && primaryDependencyHolder.DependencyId == targetDependencyId)
{
return(Inject <TSource>(args));
}
else
{
IDependencyHolder secondDependencyHolder = this.Container.GetDependencyMap(sourceDependencyId).GetSecondaryDependencyHolder(targetDependencyId);
if (secondDependencyHolder != null)
{
return((TSource)secondDependencyHolder.GetInstance(args));
}
}
}
return(default(TSource));
}
public override void Inject(object instance)
{
//Method Injection
var methodToAutoInject = this._type.GetMembers().Where(ctor => Attribute.IsDefined(ctor, typeof(AutoInjectAttribute)) && ctor.MemberType == MemberTypes.Method);
foreach (var method in methodToAutoInject)
{
MethodInfo methodInfo = (MethodInfo)method;
object[] paramValues = new object[methodInfo.GetParameters().Length];
int index = 0;
foreach (ParameterInfo paramInfo in methodInfo.GetParameters())
{
string dependencyId = GetParamInjectDependency(paramInfo) ?? paramInfo.ParameterType.GetDependencyId();
if (this.Container.ContainsDependency(dependencyId))
{
IDependencyHolder primaryDepHolder = this.Container.GetDependencyMap(dependencyId).PrimaryDependencyHolder;
if (primaryDepHolder == null)
{
throw new PrimaryOrPreferredTargetDependencyNotFound("Source dependency: " + dependencyId);
}
object memberValue = primaryDepHolder.GetInstance(GetParamInjectValues(paramInfo));
paramValues[index] = memberValue;
index++;
}
else
{
string errMsg = string.Format("{0} dependency not found or is not attributed as Injectable while auto injecting the parameter '{1}' of method '{2}' of dependency: {3}", dependencyId, paramInfo.Name, methodInfo.Name, this._type.GetDependencyId());
throw new NonInjectableTypeException(errMsg);
}
}
var o = methodInfo.Invoke(instance, paramValues);
}
this.InjectNext(instance);
}
public void DependencyMap_GetSecondaryDependencyHolder_Test()
{
//arrange
Type type = typeof(foo);
Mock <IDependencyHolder> mockDepHolder = new Mock <IDependencyHolder>();
mockDepHolder.SetupGet(dh => dh.DependencyId).Returns(type.GetDependencyId());
Mock <IDIContainer> mockContainer = new Mock <IDIContainer>();
IDependencyMap dependencyMap = new DependencyMap(mockContainer.Object, type);
dependencyMap.SecondaryDependencyHolders.Add(mockDepHolder.Object);
//act
IDependencyHolder actualDepHolder = dependencyMap.GetSecondaryDependencyHolder(type.GetDependencyId());
//assert
Assert.IsNotNull(actualDepHolder);
}
