c# - 在运行时解析成员名称

标签 c# c#-4.0 reflection c#-5.0 overload-resolution

给定一个类型、一个名称和一个签名,我如何查找名称为名称的成员 和签名 signature 使用 7.4 的 C# 规则(7.4 是 C# 语言规范中的章节号)(或者至少是其中的一部分……假设我可以接受完全匹配,没有转换/转换)在运行时?我需要得到一个 MethodInfo/PropertyInfo/... 因为那时我必须将它与反射一起使用(更准确地说,我正在尝试构建一个 Expression.ForEach 构建器(一个能够创建表示 foreach 语句的表达式树的工厂),并且与我拥有的 C# foreach 完美像素能够进行 duck-typing 并搜索 GetEnumerator 方法(在集合中)、Current 属性和 MoveNext 方法(在集合中枚举器),如 8.8.4 中所写)

问题(问题的一个例子)

class C1
{
    public int Current { get; set; }

    public object MoveNext()
    {
        return null;
    }
}

class C2 : C1
{
    public new long Current { get; set; }

    public new bool MoveNext()
    {
        return true;
    }
}

class C3 : C2
{
}

var m = typeof(C3).GetMethods(); // I get both versions of MoveNext()
var p = typeof(C3).GetProperties(); // I get both versions of Current

很明显,如果我尝试 typeof(C3).GetProperty("Current"),我会得到一个 AmbiguousMatchException 异常。

接口(interface)存在类似但不同的问题:

interface I0
{
    int Current { get; set; }
}

interface I1 : I0
{
    new long Current { get; set; }
}

interface I2 : I1, I0
{
    new object Current { get; set; }
}

interface I3 : I2
{
}

在这里,如果我尝试执行 typeof(I3).GetProperties(),我不会获得 Current 属性(这是已知的,参见示例GetProperties() to return all properties for an interface inheritance hierarchy ),但我不能简单地扁平化接口(interface),因为那样我就不知道谁在隐藏谁。

我知道这个问题可能在 Microsoft.CSharp.RuntimeBinder 命名空间(在 Microsoft.CSharp 程序集中声明)的某处得到解决。这是因为我正在尝试使用 C# 规则,当你有动态方法调用时,成员查找是必要的,但我找不到任何东西(然后我会得到一个 Expression或者直接调用)。

经过一番思考,很明显 Microsoft.VisualBasic 程序集中有类似的东西。 VB.NET 支持后期绑定(bind)。它在 Microsoft.VisualBasic.CompilerServices.NewLateBinding 中,但它不公开后期有界方法。

最佳答案

(注意:隐藏 = 隐藏 = C# 中的方法/属性/事件定义中的新内容)

没有人回应,所以我将在此期间发布我编写的代码。我讨厌发布 400 行代码,但我想完整。主要有两种方法:GetVisibleMethodsGetVisibleProperties .它们是 Type 的扩展方法类(class)。它们将返回类型的公共(public)可见(非阴影/非覆盖)方法/属性。他们甚至应该处理 VB.NET 程序集(VB.NET 通常使用 hide-by-name 阴影而不是像 C# 那样使用 hidebysig)。他们将结果缓存在两个静态集合中(MethodsProperties)。该代码适用于 C# 4.0,所以我使用 ConcurrentDictionary<T, U> .如果您使用的是 C# 3.5,则可以将其替换为 Dictionary<T, U>但你必须用 lock 来保护它() { } 当您从中读取和写入时。

它是如何工作的?它通过递归工作(我知道递归通常是不好的,但我希望没有人会创建 1.000 级继承链)。

对于“真正的”类型(非接口(interface)),它向上走一层(使用递归,所以这一层向上可以向上一层等等)并且,从返回的方法/属性列表中,它删除了重载/隐藏的方法/属性。

对于接口(interface),它有点复杂。 Type.GetInterfaces()返回所有被继承的接口(interface),忽略是直接继承还是间接继承。对于这些接口(interface)中的每一个,都会计算(通过递归)声明的方法/属性的列表。此列表与接口(interface)隐藏的方法/属性列表配对(HashSet<MethodInfo>/HashSet<PropertyInfo>)。这些被一个接口(interface)或另一个接口(interface)隐藏的方法/属性将从接口(interface)返回的所有其他方法/属性中删除(因此,如果您有 I1Method1(int)I2 继承自 I1 重新声明 Method1(int) 和这样做会隐藏 I1.Method1I3 继承自 I1I2I2 隐藏 I1.Method1 的事实将应用于从探索 I1 返回的方法,因此删除 I1.Method1(int) (发生这种情况是因为我没有为接口(interface)生成继承映射,我只是看看隐藏了什么))。

从返回的方法/属性集合中,可以使用 Linq 找到要查找的方法/属性。请注意,对于接口(interface),您可以找到多个具有给定签名的方法/属性。一个例子:

interface I1
{
    void Method1();
}

interface I2
{
    void Method1();
}

interface I3 : I1, I2
{
}

I3将返回两个 Method1() .

代码:

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

public static class TypeEx
{
    /// <summary>
    /// Type, Tuple&lt;Methods of type, (for interfaces)methods of base interfaces shadowed&gt;
    /// </summary>
    public static readonly ConcurrentDictionary<Type, Tuple<MethodInfo[], HashSet<MethodInfo>>> Methods = new ConcurrentDictionary<Type, Tuple<MethodInfo[], HashSet<MethodInfo>>>();

    /// <summary>
    /// Type, Tuple&lt;Properties of type, (for interfaces)properties of base interfaces shadowed&gt;
    /// </summary>
    public static readonly ConcurrentDictionary<Type, Tuple<PropertyInfo[], HashSet<PropertyInfo>>> Properties = new ConcurrentDictionary<Type, Tuple<PropertyInfo[], HashSet<PropertyInfo>>>();

    public static MethodInfo[] GetVisibleMethods(this Type type)
    {
        if (type.IsInterface)
        {
            return (MethodInfo[])type.GetVisibleMethodsInterfaceImpl().Item1.Clone();
        }

        return (MethodInfo[])type.GetVisibleMethodsImpl().Clone();
    }

    public static PropertyInfo[] GetVisibleProperties(this Type type)
    {
        if (type.IsInterface)
        {
            return (PropertyInfo[])type.GetVisiblePropertiesInterfaceImpl().Item1.Clone();
        }

        return (PropertyInfo[])type.GetVisiblePropertiesImpl().Clone();
    }

    private static MethodInfo[] GetVisibleMethodsImpl(this Type type)
    {
        Tuple<MethodInfo[], HashSet<MethodInfo>> tuple;

        if (Methods.TryGetValue(type, out tuple))
        {
            return tuple.Item1;
        }

        var methods = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);

        if (type.BaseType == null)
        {
            Methods.TryAdd(type, Tuple.Create(methods, (HashSet<MethodInfo>)null));
            return methods;
        }

        var baseMethods = type.BaseType.GetVisibleMethodsImpl().ToList();

        foreach (var method in methods)
        {
            if (method.IsHideByName())
            {
                baseMethods.RemoveAll(p => p.Name == method.Name);
            }
            else
            {
                int numGenericArguments = method.GetGenericArguments().Length;
                var parameters = method.GetParameters();

                baseMethods.RemoveAll(p =>
                {
                    if (!method.EqualSignature(numGenericArguments, parameters, p))
                    {
                        return false;
                    }

                    return true;
                });
            }
        }

        if (baseMethods.Count == 0)
        {
            Methods.TryAdd(type, Tuple.Create(methods, (HashSet<MethodInfo>)null));
            return methods;
        }

        var methods3 = new MethodInfo[methods.Length + baseMethods.Count];

        Array.Copy(methods, 0, methods3, 0, methods.Length);
        baseMethods.CopyTo(methods3, methods.Length);

        Methods.TryAdd(type, Tuple.Create(methods3, (HashSet<MethodInfo>)null));
        return methods3;
    }

    private static Tuple<MethodInfo[], HashSet<MethodInfo>> GetVisibleMethodsInterfaceImpl(this Type type)
    {
        Tuple<MethodInfo[], HashSet<MethodInfo>> tuple;

        if (Methods.TryGetValue(type, out tuple))
        {
            return tuple;
        }

        var methods = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public);

        var baseInterfaces = type.GetInterfaces();

        if (baseInterfaces.Length == 0)
        {
            tuple = Tuple.Create(methods, new HashSet<MethodInfo>());
            Methods.TryAdd(type, tuple);
            return tuple;
        }

        var baseMethods = new List<MethodInfo>();

        var baseMethodsTemp = new MethodInfo[baseInterfaces.Length][];

        var shadowedMethods = new HashSet<MethodInfo>();

        for (int i = 0; i < baseInterfaces.Length; i++)
        {
            var tuple2 = baseInterfaces[i].GetVisibleMethodsInterfaceImpl();
            baseMethodsTemp[i] = tuple2.Item1;
            shadowedMethods.UnionWith(tuple2.Item2);
        }

        for (int i = 0; i < baseInterfaces.Length; i++)
        {
            baseMethods.AddRange(baseMethodsTemp[i].Where(p => !shadowedMethods.Contains(p)));
        }

        foreach (var method in methods)
        {
            if (method.IsHideByName())
            {
                baseMethods.RemoveAll(p =>
                {
                    if (p.Name == method.Name)
                    {
                        shadowedMethods.Add(p);
                        return true;
                    }

                    return false;
                });
            }
            else
            {
                int numGenericArguments = method.GetGenericArguments().Length;
                var parameters = method.GetParameters();

                baseMethods.RemoveAll(p =>
                {
                    if (!method.EqualSignature(numGenericArguments, parameters, p))
                    {
                        return false;
                    }

                    shadowedMethods.Add(p);
                    return true;
                });
            }
        }

        if (baseMethods.Count == 0)
        {
            tuple = Tuple.Create(methods, shadowedMethods);
            Methods.TryAdd(type, tuple);
            return tuple;
        }

        var methods3 = new MethodInfo[methods.Length + baseMethods.Count];

        Array.Copy(methods, 0, methods3, 0, methods.Length);
        baseMethods.CopyTo(methods3, methods.Length);

        tuple = Tuple.Create(methods3, shadowedMethods);
        Methods.TryAdd(type, tuple);
        return tuple;
    }

    private static PropertyInfo[] GetVisiblePropertiesImpl(this Type type)
    {
        Tuple<PropertyInfo[], HashSet<PropertyInfo>> tuple;

        if (Properties.TryGetValue(type, out tuple))
        {
            return tuple.Item1;
        }

        var properties = type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);

        if (type.BaseType == null)
        {
            Properties.TryAdd(type, Tuple.Create(properties, (HashSet<PropertyInfo>)null));
            return properties;
        }

        var baseProperties = type.BaseType.GetVisiblePropertiesImpl().ToList();

        foreach (var property in properties)
        {
            if (property.IsHideByName())
            {
                baseProperties.RemoveAll(p => p.Name == property.Name);
            }
            else
            {
                var indexers = property.GetIndexParameters();

                baseProperties.RemoveAll(p =>
                {
                    if (!property.EqualSignature(indexers, p))
                    {
                        return false;
                    }

                    return true;
                });
            }
        }

        if (baseProperties.Count == 0)
        {
            Properties.TryAdd(type, Tuple.Create(properties, (HashSet<PropertyInfo>)null));
            return properties;
        }

        var properties3 = new PropertyInfo[properties.Length + baseProperties.Count];

        Array.Copy(properties, 0, properties3, 0, properties.Length);
        baseProperties.CopyTo(properties3, properties.Length);

        Properties.TryAdd(type, Tuple.Create(properties3, (HashSet<PropertyInfo>)null));
        return properties3;
    }

    private static Tuple<PropertyInfo[], HashSet<PropertyInfo>> GetVisiblePropertiesInterfaceImpl(this Type type)
    {
        Tuple<PropertyInfo[], HashSet<PropertyInfo>> tuple;

        if (Properties.TryGetValue(type, out tuple))
        {
            return tuple;
        }

        var properties = type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public);

        var baseInterfaces = type.GetInterfaces();

        if (baseInterfaces.Length == 0)
        {
            tuple = Tuple.Create(properties, new HashSet<PropertyInfo>());
            Properties.TryAdd(type, tuple);
            return tuple;
        }

        var baseProperties = new List<PropertyInfo>();

        var basePropertiesTemp = new PropertyInfo[baseInterfaces.Length][];

        var shadowedProperties = new HashSet<PropertyInfo>();

        for (int i = 0; i < baseInterfaces.Length; i++)
        {
            var tuple2 = baseInterfaces[i].GetVisiblePropertiesInterfaceImpl();
            basePropertiesTemp[i] = tuple2.Item1;
            shadowedProperties.UnionWith(tuple2.Item2);
        }

        for (int i = 0; i < baseInterfaces.Length; i++)
        {
            baseProperties.AddRange(basePropertiesTemp[i].Where(p => !shadowedProperties.Contains(p)));
        }

        foreach (var property in properties)
        {
            if (property.IsHideByName())
            {
                baseProperties.RemoveAll(p =>
                {
                    if (p.Name == property.Name)
                    {
                        shadowedProperties.Add(p);
                        return true;
                    }

                    return false;
                });
            }
            else
            {
                var indexers = property.GetIndexParameters();

                baseProperties.RemoveAll(p =>
                {
                    if (!property.EqualSignature(indexers, p))
                    {
                        return false;
                    }

                    shadowedProperties.Add(p);
                    return true;
                });
            }
        }

        if (baseProperties.Count == 0)
        {
            tuple = Tuple.Create(properties, shadowedProperties);
            Properties.TryAdd(type, tuple);
            return tuple;
        }

        var properties3 = new PropertyInfo[properties.Length + baseProperties.Count];

        Array.Copy(properties, 0, properties3, 0, properties.Length);
        baseProperties.CopyTo(properties3, properties.Length);

        tuple = Tuple.Create(properties3, shadowedProperties);
        Properties.TryAdd(type, tuple);
        return tuple;
    }

    private static bool EqualSignature(this MethodInfo method1, int numGenericArguments1, ParameterInfo[] parameters1, MethodInfo method2)
    {
        // To shadow by signature a method must have same name, same number of 
        // generic arguments, same number of parameters and same parameters' type
        if (method1.Name != method2.Name)
        {
            return false;
        }

        if (numGenericArguments1 != method2.GetGenericArguments().Length)
        {
            return false;
        }

        var parameters2 = method2.GetParameters();

        if (!parameters1.EqualParameterTypes(parameters2))
        {
            return false;
        }

        return true;
    }

    private static bool EqualSignature(this PropertyInfo property1, ParameterInfo[] indexers1, PropertyInfo property2)
    {
        // To shadow by signature a property must have same name, 
        // same number of indexers and same indexers' type
        if (property1.Name != property2.Name)
        {
            return false;
        }

        var parameters2 = property1.GetIndexParameters();

        if (!indexers1.EqualParameterTypes(parameters2))
        {
            return false;
        }

        return true;
    }

    private static bool EqualParameterTypes(this ParameterInfo[] parameters1, ParameterInfo[] parameters2)
    {
        if (parameters1.Length != parameters2.Length)
        {
            return false;
        }

        for (int i = 0; i < parameters1.Length; i++)
        {
            if (parameters1[i].IsOut != parameters2[i].IsOut)
            {
                return false;
            }

            if (parameters1[i].ParameterType.IsGenericParameter)
            {
                if (!parameters2[i].ParameterType.IsGenericParameter)
                {
                    return false;
                }

                if (parameters1[i].ParameterType.GenericParameterPosition != parameters2[i].ParameterType.GenericParameterPosition)
                {
                    return false;
                }
            }
            else if (parameters1[i].ParameterType != parameters2[i].ParameterType)
            {
                return false;
            }
        }

        return true;
    }

    private static bool IsHideByName(this MethodInfo method)
    {
        if (!method.Attributes.HasFlag(MethodAttributes.HideBySig) && (!method.Attributes.HasFlag(MethodAttributes.Virtual) || method.Attributes.HasFlag(MethodAttributes.NewSlot)))
        {
            return true;
        }

        return false;
    }

    private static bool IsHideByName(this PropertyInfo property)
    {
        var get = property.GetGetMethod();

        if (get != null && get.IsHideByName())
        {
            return true;
        }

        var set = property.GetSetMethod();

        if (set != null && set.IsHideByName())
        {
            return true;
        }

        return false;
    }
}

关于c# - 在运行时解析成员名称,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/11413313/

相关文章:

c# - 如何连接两个异常?

java - 自动将字符串转换为动态确定的类型?

c# - 无法理解 CSS 2.1 语法

c# - Window CE 6 奇怪的文件 IO 问题

c# - 如何在 xunit 中模拟 Db 连接?

c# - 在 LINQ 中获取组的第一条记录?

c# - 反射 C# : Create instance of an object which has no default constructor

c# - Xamarin iOS,无法打开 Info.plist

c# - 从同一个类中的另一个构造函数调用构造函数

c# - 如何在 C# 4.0 中将引用类型设置为可为空