Я пытаюсь получить MethodInfo для метода Where типа Enumerable:
typeof (Enumerable).GetMethod("Where", new Type[] {
typeof(IEnumerable<>),
typeof(Func<,>)
})
но получить ноль. Что я делаю неправильно?
Я пытаюсь получить MethodInfo для метода Where типа Enumerable:
typeof (Enumerable).GetMethod("Where", new Type[] {
typeof(IEnumerable<>),
typeof(Func<,>)
})
но получить ноль. Что я делаю неправильно?
Однако предыдущий ответ работает в некоторых случаях:
Action<IEnumerable<T>>
. Он будет рассматривать все Action<>
как совпадения, например, string.Concat(IEnumerable<string>)
и string.Concat<T>(IEnumerable<T>)
будут совпадать при поиске "Concat"
с типом IEnumerable<>
в строковом типе. Что действительно желательно, так это рекурсивная обработка вложенных универсальных типов, при этом все общие параметры рассматриваются как соответствующие друг другу независимо от имени, но НЕ соответствуют конкретным типам.type.GetMethod()
. Итак, вы можете получить желаемый метод, если вам повезет, а может и нет.BindingFlags
, чтобы избежать двусмысленности, например, когда метод производного класса «скрывает» метод базового класса. Обычно вы хотите найти методы базового класса, но не в специализированном случае, когда вы знаете, что метод, который вы ищете, находится в производном классе. Или вы можете знать, что ищете статический метод против экземпляра, публичный против частного и т. Д. И не хотите совпадать, если он неточный.type.GetMethods()
, так как он также не выполняет поиск методов в базовых интерфейсах при поиске метода для типа интерфейса. Хорошо, может быть, это придирчивость, но это еще один серьезный недостаток GetMethods()
, который стал для меня проблемой.type.GetMethods()
неэффективен, type.GetMember(name, MemberTypes.Method, ...)
вернет только методы с совпадающим именем вместо ВСЕХ методов в типе.GetGenericMethod()
может вводить в заблуждение, поскольку вы можете попытаться найти неуниверсальный метод, который имеет параметр типа где-то в типе параметра из-за общего типа объявления.Вот версия, которая решает все эти проблемы, и ее можно использовать как универсальную замену ошибочному GetMethod()
. Обратите внимание, что предоставляются два метода расширения: один с BindingFlags, а другой без (для удобства).
/// <summary>
/// Search for a method by name and parameter types.
/// Unlike GetMethod(), does 'loose' matching on generic
/// parameter types, and searches base interfaces.
/// </summary>
/// <exception cref="AmbiguousMatchException"/>
public static MethodInfo GetMethodExt( this Type thisType,
string name,
params Type[] parameterTypes)
{
return GetMethodExt(thisType,
name,
BindingFlags.Instance
| BindingFlags.Static
| BindingFlags.Public
| BindingFlags.NonPublic
| BindingFlags.FlattenHierarchy,
parameterTypes);
}
/// <summary>
/// Search for a method by name, parameter types, and binding flags.
/// Unlike GetMethod(), does 'loose' matching on generic
/// parameter types, and searches base interfaces.
/// </summary>
/// <exception cref="AmbiguousMatchException"/>
public static MethodInfo GetMethodExt( this Type thisType,
string name,
BindingFlags bindingFlags,
params Type[] parameterTypes)
{
MethodInfo matchingMethod = null;
// Check all methods with the specified name, including in base classes
GetMethodExt(ref matchingMethod, thisType, name, bindingFlags, parameterTypes);
// If we're searching an interface, we have to manually search base interfaces
if (matchingMethod == null && thisType.IsInterface)
{
foreach (Type interfaceType in thisType.GetInterfaces())
GetMethodExt(ref matchingMethod,
interfaceType,
name,
bindingFlags,
parameterTypes);
}
return matchingMethod;
}
private static void GetMethodExt( ref MethodInfo matchingMethod,
Type type,
string name,
BindingFlags bindingFlags,
params Type[] parameterTypes)
{
// Check all methods with the specified name, including in base classes
foreach (MethodInfo methodInfo in type.GetMember(name,
MemberTypes.Method,
bindingFlags))
{
// Check that the parameter counts and types match,
// with 'loose' matching on generic parameters
ParameterInfo[] parameterInfos = methodInfo.GetParameters();
if (parameterInfos.Length == parameterTypes.Length)
{
int i = 0;
for (; i < parameterInfos.Length; ++i)
{
if (!parameterInfos[i].ParameterType
.IsSimilarType(parameterTypes[i]))
break;
}
if (i == parameterInfos.Length)
{
if (matchingMethod == null)
matchingMethod = methodInfo;
else
throw new AmbiguousMatchException(
"More than one matching method found!");
}
}
}
}
/// <summary>
/// Special type used to match any generic parameter type in GetMethodExt().
/// </summary>
public class T
{ }
/// <summary>
/// Determines if the two types are either identical, or are both generic
/// parameters or generic types with generic parameters in the same
/// locations (generic parameters match any other generic paramter,
/// but NOT concrete types).
/// </summary>
private static bool IsSimilarType(this Type thisType, Type type)
{
// Ignore any 'ref' types
if (thisType.IsByRef)
thisType = thisType.GetElementType();
if (type.IsByRef)
type = type.GetElementType();
// Handle array types
if (thisType.IsArray && type.IsArray)
return thisType.GetElementType().IsSimilarType(type.GetElementType());
// If the types are identical, or they're both generic parameters
// or the special 'T' type, treat as a match
if (thisType == type || ((thisType.IsGenericParameter || thisType == typeof(T))
&& (type.IsGenericParameter || type == typeof(T))))
return true;
// Handle any generic arguments
if (thisType.IsGenericType && type.IsGenericType)
{
Type[] thisArguments = thisType.GetGenericArguments();
Type[] arguments = type.GetGenericArguments();
if (thisArguments.Length == arguments.Length)
{
for (int i = 0; i < thisArguments.Length; ++i)
{
if (!thisArguments[i].IsSimilarType(arguments[i]))
return false;
}
return true;
}
}
return false;
}
Обратите внимание, что метод расширения IsSimilarType(Type)
может быть опубликован и может быть полезен сам по себе. Я знаю, имя невелико - вы можете придумать лучшее, но может потребоваться очень много времени, чтобы объяснить, что оно делает. Кроме того, я добавил еще одно улучшение, проверив типы «ref» и массив (ссылки игнорируются при сопоставлении, но размеры массивов должны совпадать).
Итак, вот как Microsoft должна это сделать. Это действительно не так уж и сложно.
Да, я знаю, вы можете сократить часть этой логики с помощью Linq, но я не большой поклонник Linq в таких низкоуровневых подпрограммах, как эта, и только если Linq так же прост в использовании, как и исходный код, что часто НЕ бывает, ИМО.
Если вы любите Linq и должны, вы можете заменить внутреннюю часть IsSimilarType()
на это (превращает 8 строк в 1):
if (thisArguments.Length == arguments.Length)
return !thisArguments.Where((t, i) => !t.IsSimilarType(arguments[i])).Any();
И последнее: если вы ищете универсальный метод с универсальным параметром, например Method<T>(T, T[])
, вам нужно будет найти Тип, который является универсальным параметром (IsGenericParameter == true
) для передачи в качестве типа параметра (подойдет любой , из-за соответствия "подстановочным знакам"). Однако вы не можете просто сделать new Type()
- вам нужно найти настоящий (или построить его с помощью TypeBuilder). Чтобы упростить эту задачу, я добавил объявление public class T
и добавил логику в IsSimilarType()
, чтобы проверить его и сопоставить с любым универсальным параметром. Если вам нужен T[]
, просто используйте T.MakeArrayType(1)
.
К сожалению, обобщения не поддерживаются в .NET Reflection. В этом конкретном случае вам нужно вызвать GetMethods, а затем отфильтровать набор результатов для метода, который вы ищете. Метод расширения, подобный следующему, должен помочь.
public static class TypeExtensions
{
private class SimpleTypeComparer : IEqualityComparer<Type>
{
public bool Equals(Type x, Type y)
{
return x.Assembly == y.Assembly &&
x.Namespace == y.Namespace &&
x.Name == y.Name;
}
public int GetHashCode(Type obj)
{
throw new NotImplementedException();
}
}
public static MethodInfo GetGenericMethod(this Type type, string name, Type[] parameterTypes)
{
var methods = type.GetMethods();
foreach (var method in methods.Where(m => m.Name == name))
{
var methodParameterTypes = method.GetParameters().Select(p => p.ParameterType).ToArray();
if (methodParameterTypes.SequenceEqual(parameterTypes, new SimpleTypeComparer()))
{
return method;
}
}
return null;
}
}
С этим будет работать следующий код:
typeof(Enumerable).GetGenericMethod("Where", new Type[] { typeof(IEnumerable<>), typeof(Func<,>) });
type.GetMethods().FirstOrDefault(m => m.Name == name && m.GetParameters().Select(p => p.ParameterType).SequenceEqual(parameterTypes, new SimpleTypeComparer()));
:) Было бы лучше добавить params
к последнему параметру. 09.10.2013
SomeMethod(Type t)
, перейдяdynamicInstance.SomeMethod(other.GetType())
. Проблема в том, чтоIsSimilarType
возвращает false дляSystem.RuntimeType
иSystem.Type
. После устранения этой проблемы у меня возникли проблемы с вызовом методов с общими параметрами. Весь ваш код работает не во всех случаях, поэтому я бы сказал, что проблема в очень сложна. 27.12.2012if (!parameterInfos[i].IsOptional && !parameterInfos[i].ParameterType.IsSimilarType(parameterTypes[i]))
. Потребуются дополнительные изменения кода для поддержки исключения необязательных параметров. 18.06.2013typeof(object)
, вместо этого ваша подпись методаSomeMethod(Type t)
гласит, что вы действительно должны передатьtypeof(Type)
. 08.10.2013GetMethodExt
, если метод такой общий:void Pita<R, S, T>(R r, S s, T t)
? А когда у вас есть две общие перегрузкиvoid Pita<S, T>(S s, T t)
иvoid Pita<S, T>(T t, S s)
, как получитьMethodInfo
первую перегрузку? Короче говоря, с дженериками такие штуки очень и очень тяжело. Если MS не добавит в C # какой-нибудь новый индикатор для обозначения универсальных типов, это невозможно. 10.10.2013T.MakeArrayType(1)
вместоtypeof(T[])
? Просто учусь, не принимайте это на свой счет. 10.10.2013