/// <summary>
/// Return the sequence of methods to call while building the target object.
/// </summary>
/// <param name = "context">Current build context.</param>
/// <param name = "resolverPolicyDestination">The <see cref = 'IPolicyList' /> to add any
/// generated resolver objects into.</param>
/// <returns>Sequence of methods to call.</returns>
public IEnumerable<SelectedMethod> SelectMethods(IBuilderContext context, IPolicyList resolverPolicyDestination)
{
foreach (Pair<MethodInfo, IEnumerable<InjectionParameterValue>> method in methods)
{
Type typeToBuild = context.BuildKey.Type;
SelectedMethod selectedMethod;
var typeReflector = new ReflectionHelper(method.First.DeclaringType);
var methodReflector = new MethodReflectionHelper(method.First);
if (!methodReflector.MethodHasOpenGenericParameters && !typeReflector.IsOpenGeneric)
{
selectedMethod = new SelectedMethod(method.First);
}
else
{
Type[] closedMethodParameterTypes =
methodReflector.GetClosedParameterTypes(typeToBuild.GetGenericArguments());
selectedMethod = new SelectedMethod(
typeToBuild.GetMethod(method.First.Name, closedMethodParameterTypes));
}
SpecifiedMemberSelectorHelper.AddParameterResolvers(
typeToBuild,
resolverPolicyDestination,
method.Second,
selectedMethod);
yield return selectedMethod;
}
}
public override bool MatchesType(Type t)
{
Guard.ArgumentNotNull(t, "t");
ReflectionHelper candidateReflector = new ReflectionHelper(t);
if (candidateReflector.IsOpenGeneric && this.parameterReflector.IsOpenGeneric)
{
return candidateReflector.Type.GetGenericTypeDefinition() ==
this.parameterReflector.Type.GetGenericTypeDefinition();
}
return t.GetTypeInfo().IsAssignableFrom(this.parameterReflector.Type.GetTypeInfo());
}
/// <summary>
/// Return a <see cref = "IDependencyResolverPolicy" /> instance that will
/// return this types value for the parameter.
/// </summary>
/// <param name = "typeToBuild">Type that contains the member that needs this parameter. Used
/// to resolve open generic parameters.</param>
/// <returns>The <see cref = "IDependencyResolverPolicy" />.</returns>
public override IDependencyResolverPolicy GetResolverPolicy(Type typeToBuild)
{
Guard.ArgumentNotNull(typeToBuild, "typeToBuild");
var parameterReflector = new ReflectionHelper(ParameterType);
Type typeToResolve = parameterReflector.Type;
if (parameterReflector.IsOpenGeneric)
{
typeToResolve = parameterReflector.GetClosedParameterType(typeToBuild.GetGenericArguments());
}
return new OptionalDependencyResolverPolicy(typeToResolve, name);
}
/// <summary>
/// Return a <see cref="IDependencyResolverPolicy"/> instance that will
/// return this types value for the parameter.
/// </summary>
/// <param name="typeToBuild">Type that contains the member that needs this parameter. Used
/// to resolve open generic parameters.</param>
/// <returns>The <see cref="IDependencyResolverPolicy"/>.</returns>
public override IDependencyResolverPolicy GetResolverPolicy(Type typeToBuild)
{
this.GuardTypeToBuildIsGeneric(typeToBuild);
this.GuardTypeToBuildHasMatchingGenericParameter(typeToBuild);
Type typeToResolve = new ReflectionHelper(typeToBuild).GetNamedGenericParameter(this.genericParameterName);
var resolverPolicies = new List<IDependencyResolverPolicy>();
foreach (InjectionParameterValue pv in this.elementValues)
{
resolverPolicies.Add(pv.GetResolverPolicy(typeToBuild));
}
return new ResolvedArrayWithElementsResolverPolicy(typeToResolve, resolverPolicies.ToArray());
}
public override IDependencyResolverPolicy GetResolverPolicy(Type typeToBuild)
{
Guard.ArgumentNotNull(typeToBuild, "typeToBuild");
var parameterReflector = new ReflectionHelper(ParameterType);
if(parameterReflector.IsGenericArray)
{
return CreateGenericArrayResolverPolicy(typeToBuild, parameterReflector);
}
if (parameterReflector.IsOpenGeneric)
{
return CreateGenericResolverPolicy(typeToBuild, parameterReflector);
}
return CreateResolverPolicy(parameterReflector.Type);
}
/// <summary>
/// Returns sequence of properties on the given type that
/// should be set as part of building that object.
/// </summary>
/// <param name="context">Current build context.</param>
/// <param name="resolverPolicyDestination">The <see cref='IPolicyList'/> to add any
/// generated resolver objects into.</param>
/// <returns>Sequence of <see cref="PropertyInfo"/> objects
/// that contain the properties to set.</returns>
public IEnumerable<SelectedProperty> SelectProperties(IBuilderContext context, IPolicyList resolverPolicyDestination)
{
Type typeToBuild = context.BuildKey.Type;
var currentTypeReflector = new ReflectionHelper(context.BuildKey.Type);
foreach (Pair<PropertyInfo, InjectionParameterValue> pair in propertiesAndValues)
{
PropertyInfo currentProperty = pair.First;
// Is this the property info on the open generic? If so, get the one
// for the current closed generic.
if (new ReflectionHelper(pair.First.DeclaringType).IsOpenGeneric)
{
currentProperty = currentTypeReflector.Type.GetTypeInfo().GetDeclaredProperty(currentProperty.Name);
}
yield return new SelectedProperty(currentProperty, pair.Second.GetResolverPolicy(typeToBuild));
}
}
/// <summary>
/// Choose the constructor to call for the given type.
/// </summary>
/// <param name="context">Current build context</param>
/// <param name="resolverPolicyDestination">The <see cref='IPolicyList'/> to add any
/// generated resolver objects into.</param>
/// <returns>The chosen constructor.</returns>
public SelectedConstructor SelectConstructor(IBuilderContext context, IPolicyList resolverPolicyDestination)
{
SelectedConstructor result;
Type typeToBuild = context.BuildKey.Type;
ReflectionHelper typeReflector = new ReflectionHelper(ctor.DeclaringType);
if (!ctorReflector.MethodHasOpenGenericParameters && !typeReflector.IsOpenGeneric)
{
result = new SelectedConstructor(ctor);
}
else
{
Type[] closedCtorParameterTypes =
ctorReflector.GetClosedParameterTypes(typeToBuild.GetGenericArguments());
result = new SelectedConstructor(typeToBuild.GetConstructor(closedCtorParameterTypes));
}
SpecifiedMemberSelectorHelper.AddParameterResolvers(typeToBuild, resolverPolicyDestination, parameterValues, result);
return result;
}
private ConstructorInfo FindConstructor(Type typeToCreate)
{
var matcher = new ParameterMatcher(this.parameterValues);
var typeToCreateReflector = new ReflectionHelper(typeToCreate);
foreach (ConstructorInfo ctor in typeToCreateReflector.InstanceConstructors)
{
if (matcher.Matches(ctor.GetParameters()))
{
return ctor;
}
}
string signature = string.Join(", ", this.parameterValues.Select(p => p.ParameterTypeName).ToArray());
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture,
Resources.NoSuchConstructor,
typeToCreate.FullName,
signature));
}
private IDependencyResolverPolicy CreateGenericArrayResolverPolicy(Type typeToBuild, ReflectionHelper parameterReflector)
{
Type arrayType = parameterReflector.GetClosedParameterType(typeToBuild.GenericTypeArguments);
return new NamedTypeDependencyResolverPolicy(arrayType, name);
}
/// <summary>
/// Create a new <see cref="TypedInjectionValue"/> that exposes
/// information about the given <paramref name="parameterType"/>.
/// </summary>
/// <param name="parameterType">Type of the parameter.</param>
protected TypedInjectionValue(Type parameterType)
{
this.parameterReflector = new ReflectionHelper(parameterType);
}
private IDependencyResolverPolicy CreateGenericResolverPolicy(Type typeToBuild,
ReflectionHelper parameterReflector)
{
return new NamedTypeDependencyResolverPolicy(
parameterReflector.GetClosedParameterType(typeToBuild.GetGenericArguments()),
name);
}
public static bool MethodHasOpenGenericParameters(MethodBase method)
{
Guard.ArgumentNotNull(method, "method");
foreach (ParameterInfo param in method.GetParameters())
{
var r = new ReflectionHelper(param.ParameterType);
if (r.IsOpenGeneric)
{
return true;
}
}
return false;
}
/// <summary>
/// Return a <see cref="IDependencyResolverPolicy"/> instance that will
/// return this types value for the parameter.
/// </summary>
/// <param name="typeToBuild">Type that contains the member that needs this parameter. Used
/// to resolve open generic parameters.</param>
/// <returns>The <see cref="IDependencyResolverPolicy"/>.</returns>
public override IDependencyResolverPolicy GetResolverPolicy(Type typeToBuild)
{
GuardTypeToBuildIsGeneric(typeToBuild);
GuardTypeToBuildHasMatchingGenericParameter(typeToBuild);
Type typeToResolve = new ReflectionHelper(typeToBuild).GetNamedGenericParameter(genericParameterName);
if (isArray)
{
typeToResolve = typeToResolve.MakeArrayType();
}
return DoGetResolverPolicy(typeToResolve, this.resolutionKey);
}
private void CheckNonGeneric(Type parameterType)
{
if (parameterType.IsGenericParameter)
{
throw new InvalidOperationException(
string.Format(
CultureInfo.CurrentCulture,
Resources.ValueNotAllowedForGenericParameterType,
parameterType.Name,
this.Value));
}
var reflector = new ReflectionHelper(parameterType);
if (reflector.IsOpenGeneric)
{
throw new InvalidOperationException(
string.Format(
CultureInfo.CurrentCulture,
Resources.ValueNotAllowedForOpenGenericType,
parameterType.Name,
this.Value));
}
if (reflector.IsGenericArray)
{
throw new InvalidOperationException(
string.Format(
CultureInfo.CurrentCulture,
Resources.ValueNotAllowedForGenericArrayType,
parameterType.Name,
this.Value));
}
}