public MethodBase Resolve(MethodReference methodReference, GenericBindingContext bindingContext)
{
Type declaringType = _typeResolver.Resolve(methodReference.DeclaringType);
BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.ExactBinding;
flags |= methodReference.HasThis ? BindingFlags.Instance : BindingFlags.Static;
IEnumerable <MethodBase> candidates = IsConstructor(methodReference.Name)
? (IEnumerable <MethodBase>)declaringType.GetConstructors(flags)
: declaringType.GetMethods(flags);
MethodBase result;
if (methodReference.IsGenericInstance)
{
MethodBase genericMethod = Resolve(methodReference.Resolve(), bindingContext);
result = BindGenericArguments(methodReference, genericMethod);
}
else
{
TypeReference[] parameterTypes = methodReference.Parameters.Select(parameter =>
parameter.ParameterType).ToArray();
result = FindMethod(candidates, methodReference.Name, parameterTypes,
methodReference.HasGenericParameters, bindingContext);
}
return(result);
}
public Type Resolve(TypeReference type, GenericBindingContext bindingContext)
{
ITypeContainer container = _moduleResolver.Resolve(type.Scope);
GenericInstanceType genericInstanceType = type as GenericInstanceType;
if (genericInstanceType != null)
{
Type genericType = Resolve(genericInstanceType.Resolve());
Type[] genericArguments = genericInstanceType.GenericArguments
.Select(argument => bindingContext.Resolve(argument))
.Select(argument => Resolve(argument, bindingContext)).ToArray();
return genericType.MakeGenericType(genericArguments);
}
return container.GetType(type.FullName);
}
public Type Resolve(TypeReference type, GenericBindingContext bindingContext)
{
ITypeContainer container = _moduleResolver.Resolve(type.Scope);
GenericInstanceType genericInstanceType = type as GenericInstanceType;
if (genericInstanceType != null)
{
Type genericType = Resolve(genericInstanceType.Resolve());
Type[] genericArguments = genericInstanceType.GenericArguments
.Select(bindingContext.Resolve)
.Select(argument => Resolve(argument, bindingContext)).ToArray();
return(genericType.MakeGenericType(genericArguments));
}
return(container.GetType(type.FullName));
}
private bool ParametersMatch(MethodBase method, TypeReference[] parameterTypes,
GenericBindingContext bindingContext)
{
var methodParameters = method.GetParameters().Select(parameter => parameter.ParameterType).ToList();
if (methodParameters.Count != parameterTypes.Length)
{
return(false);
}
for (int i = 0; i < methodParameters.Count; ++i)
{
Type methodParameter = methodParameters[i];
TypeReference otherParameter = parameterTypes[i];
if (methodParameter.IsGenericParameter)
{
if (!otherParameter.IsGenericParameter ||
otherParameter.Name != methodParameter.Name)
{
return(false);
}
}
else if (methodParameter.ContainsGenericParameters)
{
var otherParameterType = _typeResolver.Resolve(otherParameter.Resolve());
var methodParameterGeneric = methodParameter.GetGenericTypeDefinition();
if (methodParameterGeneric != otherParameterType)
{
return(false);
}
}
else
{
if (methodParameter != _typeResolver.Resolve(otherParameter, bindingContext))
{
return(false);
}
}
}
return(true);
}
private MethodBase FindMethod(IEnumerable <MethodBase> candidates, string name,
TypeReference[] parameterTypes, bool isGeneric, GenericBindingContext bindingContext)
{
var result = candidates.Where(method => method.Name == name);
result = result.Where(method => method.IsGenericMethod == isGeneric);
result = result.Where(method => ParametersMatch(method, parameterTypes, bindingContext));
return(result.Single());
}
public MethodBase Resolve(MethodReference methodReference)
{
return(Resolve(methodReference, GenericBindingContext.Create(methodReference)));
}
