public InjectionBinding ToInstance(object instance)
{
BoundTo = instance.GetType();
// just use the instance
GetInstance = (constructorInfo, constructorArgs) => instance;
// prevent injection, since this is a singleton
DoFieldAndPropertyInjection = false;
return(this);
}
/// <summary>
/// Define that the requested type is bound to a target type.
/// Every injection results in a new instance of the target type.
/// </summary>
/// <typeparam name="TType"></typeparam>
/// <returns></returns>
public InjectionBinding To <TType>()
{
BoundTo = typeof(TType);
// create the instance by invoking the construtor
GetInstance = (constructorInfo, constructorArgs) => constructorInfo.Invoke(constructorArgs);
// injection of fields and properties should happen, since we have a newly created instance
DoFieldAndPropertyInjection = true;
return(this);
}
/// <summary>
/// Instantiates the target type.
/// </summary>
/// <param name="type">The target type</param>
/// <param name="bindings">All binding definitions to be used</param>
/// <param name="invoker">Function that is used to create the instance</param>
/// <param name="doInjection">True if field- and property injections should be applied</param>
/// <returns>The target type instance</returns>
private object InstantiateInternal(Type type, List <InjectionBinding> bindings, InstantiateFunc invoker, bool doInjection)
{
object instance = null;
// search for constructor injection
var constructors = type.GetConstructors();
var constructorParams = new ArrayList();
// look for a constructor that fits
// TODO: we use the first constructor that is defined on the target type, does this work in every case?
foreach (var constructor in constructors)
{
// only use constructors that where really defined on the class and not on base classes
if (constructor.DeclaringType == constructor.ReflectedType)
{
var parameters = constructor.GetParameters();
// only do the injection if we shall do it (f.e. for singleton instance injection we will not do it)
if (doInjection)
{
// check all constructor parameters
foreach (var parameter in parameters)
{
// create an instance of the parameter type
var constructorParameter = Instantiate(parameter.ParameterType, bindings);
constructorParams.Add(constructorParameter);
}
}
// instantiate the first constructor found
instance = invoker.Invoke(constructor, constructorParams.ToArray());
// we use the first constructor that fits
break;
}
}
// only do the injection if we shall do it (f.e. for singleton instance injection we will not do it)
if (doInjection)
{
Inject(instance, bindings);
}
return(instance);
}
