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))); }