/// <summary>
/// Gets an instance of the type.
/// </summary>
/// <param name="sinject">The resolver to use to inject dependencies.</param>
/// <param name="parameters">Constructor parameters.</param>
/// <returns>An instance of the type.</returns>
public override Object GetInstance(Sinject sinject, params Object[] parameters)
{
Object instance = ConstructInstance(sinject, parameters);
InjectDependencies(sinject, instance, injectionFields, injectionProperties);
return(instance);
}
/// <summary>
/// Injects the dependencies into the specified fields and properties
/// of the specified target using the specified Sinject instance to
/// resolve the types.
/// </summary>
/// <param name="sinject">The sinjkect instance to use to resolve types.</param>
/// <param name="target">The target object.</param>
/// <param name="fields">The fields to inject into.</param>
/// <param name="properties">The properties to inject into.</param>
protected void InjectDependencies(Sinject sinject, Object target, FieldInfo[] fields, PropertyInfo[] properties)
{
foreach (FieldInfo fieldInfo in fields)
{
fieldInfo.SetValue(target, sinject.Resolve(fieldInfo.FieldType));
}
foreach (PropertyInfo propertyInfo in properties)
{
propertyInfo.SetValue(target, sinject.Resolve(propertyInfo.PropertyType), sinject.EmptyObjectArray);
}
}
/// <summary>
/// Gets an instance of the type.
/// </summary>
/// <param name="sinject">The resolver to use to inject dependencies.</param>
/// <param name="parameters">Constructor parameters.</param>
/// <returns>An instance of the type.</returns>
public override Object GetInstance(Sinject sinject, params Object[] parameters)
{
if (instance == null)
{
instance = ConstructInstance(sinject, parameters);
FieldInfo[] injectionFields = GetInjectionFields();
PropertyInfo[] injectionProperties = GetInjectionProperties();
InjectDependencies(sinject, instance, injectionFields, injectionProperties);
}
return(instance);
}
/// <summary>
/// Constructs a new instance of the type.
/// </summary>
/// <param name="sinject">A Sinject instance to use to resolve dependency types.</param>
/// <param name="parameters">Optional constructor parameters to use when no injection constructor is defined.</param>
/// <returns>An instance of the type.</returns>
/// <exception cref="DependencyMissingException"></exception>
/// <exception cref="NoSuitableConstructorFoundException"></exception>
protected Object ConstructInstance(Sinject sinject, params Object[] parameters)
{
ConstructorInfo constructorInfo = GetInjectionConstructor();
if (constructorInfo != null)
{
ParameterInfo[] parameterInfos = constructorInfo.GetParameters();
Object[] injectedParameters = new Object[parameterInfos.Length];
for (int i = 0; i < parameterInfos.Length; i++)
{
var parameterInfo = parameterInfos[i];
var missingBehavior = DependencyMissingBehavior.Null;
InjectAttribute[] injectAttributes = parameterInfo.GetCustomAttributes(typeof(InjectAttribute), false) as InjectAttribute[];
if (injectAttributes.Length > 0)
{
missingBehavior = injectAttributes[0].DependencyMissingBehavior;
}
injectedParameters[i] = sinject.Resolve(parameterInfo.ParameterType);
if (injectedParameters[i] == null && missingBehavior == DependencyMissingBehavior.Throw)
{
throw new DependencyMissingException();
}
}
return(constructorInfo.Invoke(injectedParameters));
}
constructorInfo = GetDefaultConstructor(parameters);
if (constructorInfo != null)
{
return(constructorInfo.Invoke(parameters));
}
throw new NoSuitableConstructorFoundException();
}
/// <summary> /// Gets an instance of the type. /// </summary> /// <param name="sinject">The resolver to use to inject dependencies.</param> /// <param name="parameters">Constructor parameters.</param> /// <returns>An instance of the type.</returns> public abstract Object GetInstance(Sinject sinject, params Object[] parameters);
