通过反射正确找到继承的接口属性

Question

这是一个由两部分组成的问题。首先，哪些显式属性实现绑定到IAllTogether.SomeInt，为什么编译器不抱怨歧义？当您注释掉标记的行时会这样做。

public interface IFirst
{
    int SomeInt { get; }
}

public interface ISecond
{
    int SomeInt { get; }
}

public interface ICombined : IFirst, ISecond
{
    new int SomeInt { get; } // Comment this line.
}

public interface IAllTogether : IFirst, ISecond, ICombined
{ }

public sealed class Implementation : IAllTogether
{
    int ICombined.SomeInt { get { return 0; } } // Comment this line.

    int IFirst.SomeInt { get { return 0; } }

    int ISecond.SomeInt { get { return 0; } }
}


IAllTogether t = new Implementation();
var unimportant = t.SomeInt;

第二个问题是：当给定接口Type 和属性名称时，如何找到正确的PropertyInfo？我可以使用GetInterfaces() 和GetProperty() 列出所有可能的候选人，但我怎么知道哪个是正确的？我试过typeof(IAllTogether).GetProperty("SomeInt")，但它不起作用。

编辑

看起来第一部分的答案是隐藏继承的成员解决了歧义。然而，关于第二部分甚至没有一条评论：如何可靠地为某些属性名称和接口类型找到正确的PropertyInfo。

编辑 2

澄清问题的第二部分。我正在寻找的是一种为任何未知的Type 获取正确属性的方法。基本上是这样的方法：

public static PropertyInfo GetPropertyOfInterface(Type interfaceType, string propertyName)
{
    if (!interfaceType.IsInterface)
        throw new ArgumentException();

    // for interfaceType == typeof(IAllTogether), return ICombined.SomeInt
    // for interfaceType == typeof(IFirst), return IFirst.SomeInt
}

Answer 1

很多人回答第一部分：如果一个接口隐藏了原始接口的成员，则不考虑。

使用这些信息，这是我在第二部分的尝试。欢迎对问题或改进提出意见。

public static PropertyInfo GetPropertyOfInterface(Type interfaceType, string propertyName)
{
    if (interfaceType == null)
        throw new ArgumentNullException("interfaceType");

    if (!interfaceType.IsInterface)
        throw new ArgumentException(
            string.Format("Type {0} doesn't represent an interface.",
                interfaceType.FullName),
            "interfaceType");

    // If declared in given interface, just return that.
    var declaredProperty = interfaceType.GetProperty(propertyName);
    if (declaredProperty != null)
        return declaredProperty;

    // Otherwise, first finding all the candidates.
    var candidates = new HashSet<PropertyInfo>(
        interfaceType.GetInterfaces().Select(t => t.GetProperty(propertyName)));
    candidates.Remove(null);

    if (candidates.Count == 0)
        throw new ArgumentException(
            string.Format("Property {0} not found in interface {1}.",
                propertyName, interfaceType.FullName),
            "propertyName");

    // Finally, removing all candidates the first candidates hide.
    var originalCandidates = candidates.ToList();
    candidates.ExceptWith(
        originalCandidates.SelectMany(prop => prop.DeclaringType.GetInterfaces())
                          .Select(t => t.GetProperty(propertyName)));

    if (candidates.Count != 1)
        throw new AmbiguousMatchException(
            string.Format("Property {0} is ambiguous in interface {1}.",
                propertyName, interfaceType.FullName));

    return candidates.First();
}

Answer 2

回答你的第一个问题。

编译器只需要知道接口成员是否被实现。由运行时决定调用哪个版本的成员。

在您的示例中，您使用的是显式实现。

在这种情况下，首先编译检查是否实现了SomeInt 属性。如果这是隐式实现的，它不会抱怨。如果任何一个接口属性被显式实现，编译器将检查其余接口属性是通过隐式实现还是显式实现。