反思以识别扩展方法

77

在C＃中，有没有一种使用反射的技术来确定某个方法是否已作为扩展方法添加到类中？

给定一种扩展方法（例如以下所示），是否可以确定Reverse（）已添加到字符串类？

public static class StringExtensions
{
    public static string Reverse(this string value)
    {
        char[] cArray = value.ToCharArray();
        Array.Reverse(cArray);
        return new string(cArray);
    }
}

我们正在寻找一种在单元测试中确定开发人员是否适当添加了扩展方法的机制。尝试执行此操作的一个原因是，开发人员可能会将类似的方法添加到实际类中，如果是这样，则编译器会选择该方法。

c#  reflection  extension-methods 
— 迈克·切斯
source

Answers:

116

您必须查看所有可能定义扩展方法的程序集。

查找装饰ExtensionAttribute有的类，然后查找该类中也装饰有的方法ExtensionAttribute。然后检查第一个参数的类型，以查看它是否与您感兴趣的类型匹配。

这是一些完整的代码。它可能更严格（它不是在检查类型是否嵌套，或者没有至少一个参数），但是它应该可以帮到您。

using System;
using System.Runtime.CompilerServices;
using System.Reflection;
using System.Linq;
using System.Collections.Generic;

public static class FirstExtensions
{
    public static void Foo(this string x) {}
    public static void Bar(string x) {} // Not an ext. method
    public static void Baz(this int x) {} // Not on string
}

public static class SecondExtensions
{
    public static void Quux(this string x) {}
}

public class Test
{
    static void Main()
    {
        Assembly thisAssembly = typeof(Test).Assembly;
        foreach (MethodInfo method in GetExtensionMethods(thisAssembly,
            typeof(string)))
        {
            Console.WriteLine(method);
        }
    }

    static IEnumerable<MethodInfo> GetExtensionMethods(Assembly assembly,
        Type extendedType)
    {
        var query = from type in assembly.GetTypes()
                    where type.IsSealed && !type.IsGenericType && !type.IsNested
                    from method in type.GetMethods(BindingFlags.Static
                        | BindingFlags.Public | BindingFlags.NonPublic)
                    where method.IsDefined(typeof(ExtensionAttribute), false)
                    where method.GetParameters()[0].ParameterType == extendedType
                    select method;
        return query;
    }
}
— 乔恩·斯基特
source
5
好的代码。您可以使用以下事实排除一堆方法：扩展方法必须在非通用静态类中定义。其中！type.IsGenericType && type.IsSealed
— Amy B
没错，这是一个相当简单的测试。可惜的是类型没有IsDefined等效：)我将用该代码编辑答案。
— 乔恩·斯基特
如果扩展类型是泛型，则不起作用。例如，IQueryable的扩展方法将匹配，但IQueryable <>的扩展方法将匹配。我认为它在ParameterType上失败。
— Seb Nilsson
4
@Seb：是的，要使它适用于泛型方法，需要付出更多的努力。可行，但棘手。
— Jon Skeet
1
@JonSkeet嗯，我明白了。但是，这却留下了这样的选择：任何人都可以将[Extension]属性应用于顶级静态非泛型类中的方法，而仍然不是扩展方法:)是吗？
— 2013年
12

根据John Skeet的回答，我为System.Type-type创建了自己的扩展名。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;

namespace System
{
    public static class TypeExtension
    {
        /// <summary>
        /// This Methode extends the System.Type-type to get all extended methods. It searches hereby in all assemblies which are known by the current AppDomain.
        /// </summary>
        /// <remarks>
        /// Insired by Jon Skeet from his answer on http://stackoverflow.com/questions/299515/c-sharp-reflection-to-identify-extension-methods
        /// </remarks>
        /// <returns>returns MethodInfo[] with the extended Method</returns>

        public static MethodInfo[] GetExtensionMethods(this Type t)
        {
            List<Type> AssTypes = new List<Type>();

            foreach (Assembly item in AppDomain.CurrentDomain.GetAssemblies())
            {
                AssTypes.AddRange(item.GetTypes());
            }

            var query = from type in AssTypes
                where type.IsSealed && !type.IsGenericType && !type.IsNested
                from method in type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
                where method.IsDefined(typeof(ExtensionAttribute), false)
                where method.GetParameters()[0].ParameterType == t
                select method;
            return query.ToArray<MethodInfo>();
        }

        /// <summary>
        /// Extends the System.Type-type to search for a given extended MethodeName.
        /// </summary>
        /// <param name="MethodeName">Name of the Methode</param>
        /// <returns>the found Methode or null</returns>
        public static MethodInfo GetExtensionMethod(this Type t, string MethodeName)
        {
            var mi = from methode in t.GetExtensionMethods()
                where methode.Name == MethodeName
                select methode;
            if (mi.Count<MethodInfo>() <= 0)
                return null;
            else
                return mi.First<MethodInfo>();
        }
    }
}

它从当前AppDomain获取所有程序集，并搜索扩展方法。

用法：

Type t = typeof(Type);
MethodInfo[] extendedMethods = t.GetExtensionMethods();
MethodInfo extendedMethodInfo = t.GetExtensionMethod("GetExtensionMethods");

下一步将使用方法扩展System.Type，该方法将返回所有方法（以及扩展后的“常规”方法）

— 沃尔夫冈·斯泰哈默
source
5

这将返回以某种类型定义的所有扩展方法的列表，包括通用方法：

public static IEnumerable<KeyValuePair<Type, MethodInfo>> GetExtensionMethodsDefinedInType(this Type t)
{
    if (!t.IsSealed || t.IsGenericType || t.IsNested)
        return Enumerable.Empty<KeyValuePair<Type, MethodInfo>>();

    var methods = t.GetMethods(BindingFlags.Public | BindingFlags.Static)
                   .Where(m => m.IsDefined(typeof(ExtensionAttribute), false));

    List<KeyValuePair<Type, MethodInfo>> pairs = new List<KeyValuePair<Type, MethodInfo>>();
    foreach (var m in methods)
    {
        var parameters = m.GetParameters();
        if (parameters.Length > 0)
        {
            if (parameters[0].ParameterType.IsGenericParameter)
            {
                if (m.ContainsGenericParameters)
                {
                    var genericParameters = m.GetGenericArguments();
                    Type genericParam = genericParameters[parameters[0].ParameterType.GenericParameterPosition];
                    foreach (var constraint in genericParam.GetGenericParameterConstraints())
                        pairs.Add(new KeyValuePair<Type, MethodInfo>(parameters[0].ParameterType, m));
                }
            }
            else
                pairs.Add(new KeyValuePair<Type, MethodInfo>(parameters[0].ParameterType, m));
        }
    }

    return pairs;
}

唯一的问题是：返回的类型与typeof（..）所期望的不同，因为它是通用参数类型。为了找到给定类型的所有扩展方法，您必须比较所有基本类型的GUID和Type的接口，例如：

public List<MethodInfo> GetExtensionMethodsOf(Type t)
{
    List<MethodInfo> methods = new List<MethodInfo>();
    Type cur = t;
    while (cur != null)
    {

        TypeInfo tInfo;
        if (typeInfo.TryGetValue(cur.GUID, out tInfo))
            methods.AddRange(tInfo.ExtensionMethods);


        foreach (var iface in cur.GetInterfaces())
        {
            if (typeInfo.TryGetValue(iface.GUID, out tInfo))
                methods.AddRange(tInfo.ExtensionMethods);
        }

        cur = cur.BaseType;
    }
    return methods;
}

要完成：

我保留了一个类型信息对象的字典，该对象是在迭代所有程序集的所有类型时构建的：

private Dictionary<Guid, TypeInfo> typeInfo = new Dictionary<Guid, TypeInfo>();

其中TypeInfo定义为：

public class TypeInfo
{
    public TypeInfo()
    {
        ExtensionMethods = new List<MethodInfo>();
    }

    public List<ConstructorInfo> Constructors { get; set; }

    public List<FieldInfo> Fields { get; set; }
    public List<PropertyInfo> Properties { get; set; }
    public List<MethodInfo> Methods { get; set; }

    public List<MethodInfo> ExtensionMethods { get; set; }
}
— 德雷克7707
source
就目前而言，您的代码为多个约束添加了多个相同的KVP，并且添加的“明显”修正（实际上对于单个约束更正确）(constraint, m}是不正确的，因为约束是“和”而非“或”。
— Mark Hurd
实际上，从编译器的角度来看，因为它不将约束视为差异化因素，所以当前代码具有一些优点：只需删除foreach约束行即可。但这并不能帮助我们通过反射实现扩展方法：-(
— Mark Hurd
3

澄清一下Jon掩盖的一点...向类“添加”扩展方法不会以任何方式更改类。这只是C＃编译器执行的一些旋转操作。

因此，使用您的示例，您可以编写

string rev = myStr.Reverse();

但是写到程序集的MSIL就像您编写的一样：

string rev = StringExtensions.Reverse(myStr);

编译器只是让您愚弄自己以为您正在调用String方法。

— 詹姆斯·柯伦
source
3
是。我完全知道编译器正在“神奇”地隐藏细节。这就是我们有兴趣在单元测试中检测该方法是否是扩展方法的原因之一。
— Mike Chess
2

尝试执行此操作的一个原因是，开发人员可能会将类似的方法添加到实际类中，如果是这样，则编译器会选择该方法。

  • 假设定义了一个扩展方法void Foo（this Customer someCustomer）。
  • 同样，假设修改了Customer并添加了void Foo（）方法。
  • 然后，Customer上的新方法将覆盖/隐藏扩展方法。

此时，调用旧Foo方法的唯一方法是：

CustomerExtension.Foo(myCustomer);
— 艾米·B
source
0 
void Main()
{
    var test = new Test();
    var testWithMethod = new TestWithExtensionMethod();
    Tools.IsExtensionMethodCall(() => test.Method()).Dump();
    Tools.IsExtensionMethodCall(() => testWithMethod.Method()).Dump();
}

public class Test 
{
    public void Method() { }
}

public class TestWithExtensionMethod
{
}

public static class Extensions
{
    public static void Method(this TestWithExtensionMethod test) { }
}

public static class Tools
{
    public static MethodInfo GetCalledMethodInfo(Expression<Action> expr)
    {
        var methodCall = expr.Body as MethodCallExpression;
        return methodCall.Method;
    }

    public static bool IsExtensionMethodCall(Expression<Action> expr)
    {
        var methodInfo = GetCalledMethodInfo(expr);
        return methodInfo.IsStatic;
    }
}

输出：

假

真正

— 比利
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.