private void ApplyInjectees(InjecteeCollection injectees)
{
foreach (var classInjectee in injectees.Where(i => !(i is TypeStubInjectee)))
{
if (classInjectee is TypeInjectee)
{
foreach (var injectee in ((TypeInjectee)classInjectee).Injectees)
{
if (injectee is FieldInjecteeBase)
{
ApplyFieldInjection((FieldInjecteeBase)injectee);
}
else if (injectee is MethodInjecteeBase)
{
ApplyMethodInjection((MethodInjecteeBase)injectee);
}
}
}
else if (classInjectee is TypeInjecteeBase)
{
ApplyClassInjection((TypeInjecteeBase)classInjectee);
}
}
}
private InjecteeCollection GetInjectees(SR.Assembly targetAssembly, SR.Assembly injectionAssembly)
{
_classInjectees = new List<TypeInjecteeBase>();
var injectees = new InjecteeCollection();
var injectionAssemblyTypes = injectionAssembly.GetTypes();
foreach (var injectionType in injectionAssemblyTypes)
{
var classAttrs = injectionType.GetCustomAttributes(typeof(InjectionAttributeBase), false);
if (classAttrs.Count(a => a != null) >= 2)
throw new InvalidOperationException("Can not define multiple class attributes for the same class");
var classAttr = classAttrs.Select(a => a as ITypeAttribute).FirstOrDefault(a => a != null);
if (classAttr == null)
continue;
if (classAttr is TypeAddInjectionAttribute)
{
var classAddInjectee = (TypeAddInjectee)classAttr.GetInjectee(null, injectionType);
if (!String.IsNullOrEmpty(classAddInjectee.Attr.ParentFullName))
classAddInjectee.ParentType = targetAssembly.GetType(classAddInjectee.Attr.ParentFullName, true);
injectees.Add(classAddInjectee);
_classInjectees.Add(classAddInjectee);
}
else
{
var name = !String.IsNullOrEmpty(classAttr.FullName) ? classAttr.FullName : injectionType.GetNormalizedName();
var targetType = targetAssembly.GetType(name, true);
var baseClassInjectee = classAttr.GetInjectee(targetType, injectionType);
injectees.Add(baseClassInjectee);
_classInjectees.Add(baseClassInjectee);
}
}
foreach (var baseClassInjectee in _classInjectees)
{
var classInjectee = baseClassInjectee as TypeInjectee;
if (classInjectee != null)
{
foreach (var field in classInjectee.InjecteeType.GetFields(BINDING_FLAGS))
{
var fieldAttrs = field.GetCustomAttributes(typeof(InjectionAttributeBase), false);
if (fieldAttrs.Count(a => a != null) >= 2)
throw new InvalidOperationException("Can not define multiple field attributes for the same field");
var fieldAttr = fieldAttrs.Select(a => a as IFieldAttribute).FirstOrDefault(a => a != null);
if (fieldAttr == null)
continue;
var targetField = GetTargetField(fieldAttr, classInjectee.TargetType, field);
var fieldInjectee = fieldAttr.GetInjectee(targetField, field, classInjectee);
classInjectee.Injectees.Add(fieldInjectee);
}
foreach (var method in classInjectee.InjecteeType.GetMethods(BINDING_FLAGS))
{
var methodAttrs = method.GetCustomAttributes(typeof(InjectionAttributeBase), false);
if (methodAttrs.Count(a => a != null) >= 2)
throw new InvalidOperationException("Can not define multiple method attributes for the same method");
var methodAttr = methodAttrs.Select(a => a as IMethodAttribute).FirstOrDefault(a => a != null);
if (methodAttr == null)
continue;
var targetMethod = GetTargetMethod(methodAttr, classInjectee.TargetType, method);
var methodInjectee = methodAttr.GetInjectee(targetMethod, method, classInjectee);
classInjectee.Injectees.Add(methodInjectee);
}
}
}
return injectees;
}
public TypeInjectee(TypeInjectionAttribute attr, Type targetType, Type injecteeType)
: base(attr, targetType, injecteeType)
{
Injectees = new InjecteeCollection();
}
