为什么 GetProperties 两次列出受保护的属性（在通用基类中声明）？

Question

当我声明以下简单类时：

class Class1<T>
{
    protected virtual T Prop1 { get; set; }
    protected virtual string Prop2 { get; set; }
}

class Class2 : Class1<string>
{
    protected override string Prop1 { get; set; }
    protected override string Prop2 { get; set; }
}

现在我使用反射来获取 Class2 的属性，如下所示：

var hProperties = typeof(Class2).GetProperties(BindingFlags.NonPublic | BindingFlags.Instance);

那么 Prop2 将被列出一次，而 Prop1 将被列出两次！这种行为对我来说似乎很奇怪。 Prop1和Prop2不应该被视为相同吗？？

如何在 hProperties 中只使用一次 Prop1？我不想使用 BindingFlags.DeclaredOnly，因为我还想获得 Class1 的其他未被覆盖的受保护属性。

Answer 1

让我们看看编译后的程序集的元数据，以确保这两个属性除了名称之外具有相同的结构：

我使用 ILDASM 而不是通常的反编译器工具来确保没有任何内容被隐藏或以更友好的方式显示。除了名称之外，这两个属性是相同的。

返回的两个Prop1 属性之一来自Class1，其中一个来自Class2。

这似乎是一个错误。该错误似乎是基类成员未正确添加到结果中。当DeclaredOnly 未指定时all inherited properties should be returned as well。

我正在使用 DotPeek 和 Reflector VS 扩展，它允许调试反编译的 BCL 代码来调试反射代码。这个问题中看到的行为是在这个方法中触发的：

    private void PopulateProperties(RuntimeType.RuntimeTypeCache.Filter filter, RuntimeType declaringType, Dictionary<string, List<RuntimePropertyInfo>> csPropertyInfos, bool[] usedSlots, ref RuntimeType.ListBuilder<RuntimePropertyInfo> list)
    {
      int token = RuntimeTypeHandle.GetToken(declaringType);
      if (MetadataToken.IsNullToken(token))
        return;
      MetadataEnumResult result;
      RuntimeTypeHandle.GetMetadataImport(declaringType).EnumProperties(token, out result);
      RuntimeModule module = RuntimeTypeHandle.GetModule(declaringType);
      int numVirtuals = RuntimeTypeHandle.GetNumVirtuals(declaringType);
      for (int index1 = 0; index1 < result.Length; ++index1)
      {
        int num = result[index1];
        if (filter.RequiresStringComparison())
        {
          if (ModuleHandle.ContainsPropertyMatchingHash(module, num, filter.GetHashToMatch()))
          {
            Utf8String name = declaringType.GetRuntimeModule().MetadataImport.GetName(num);
            if (!filter.Match(name))
              continue;
          }
          else
            continue;
        }
        bool isPrivate;
        RuntimePropertyInfo runtimePropertyInfo = new RuntimePropertyInfo(num, declaringType, this.m_runtimeTypeCache, out isPrivate);
        if (usedSlots != null)
        {
          if (!(declaringType != this.ReflectedType) || !isPrivate)
          {
            MethodInfo methodInfo = runtimePropertyInfo.GetGetMethod();
            if (methodInfo == (MethodInfo) null)
              methodInfo = runtimePropertyInfo.GetSetMethod();
            if (methodInfo != (MethodInfo) null)
            {
              int slot = RuntimeMethodHandle.GetSlot((IRuntimeMethodInfo) methodInfo);
              if (slot < numVirtuals)
              {
                if (!usedSlots[slot])
                  usedSlots[slot] = true;
                else
                  continue;
              }
            }
            if (csPropertyInfos != null)
            {
              string name = runtimePropertyInfo.Name;
              List<RuntimePropertyInfo> list1 = csPropertyInfos.GetValueOrDefault(name);
              if (list1 == null)
              {
                list1 = new List<RuntimePropertyInfo>(1);
                csPropertyInfos[name] = list1;
              }
              for (int index2 = 0; index2 < list1.Count; ++index2)
              {
                if (runtimePropertyInfo.EqualsSig(list1[index2]))
                {
                  list1 = (List<RuntimePropertyInfo>) null;
                  break;
                }
              }
              if (list1 != null)
                list1.Add(runtimePropertyInfo);
              else
                continue;
            }
            else
            {
              bool flag = false;
              for (int index2 = 0; index2 < list.Count; ++index2)
              {
                if (runtimePropertyInfo.EqualsSig(list[index2]))
                {
                  flag = true;
                  break;
                }
              }
              if (flag)
                continue;
            }
          }
          else
            continue;
        }
        list.Add(runtimePropertyInfo);
      }
    }

为什么公共属性的行为会消失？

      if (!(declaringType != this.ReflectedType) || !isPrivate)

有一个检查。

Class1<string>.Prop2 在这里被过滤掉了：

              bool flag = false;
              for (int index2 = 0; index2 < list.Count; ++index2)
              {
                if (runtimePropertyInfo.EqualsSig(list[index2]))
                {
                  flag = true;
                  break;
                }
              }
              if (flag)
                continue;

因为EqualsSig 返回真。如果您要求私人成员，似乎属性会按名称和 sig 进行重复数据删除......我不知道为什么。不过似乎是故意的。

遵循这个复杂的代码很累。 This is better and commented. 我怀疑他们正在删除私有属性，因为您可以通过从某个类继承来提升权限以获取它的所有私有成员。

答案如下：

// For backward compatibility, even if the vtable slots don't match, we will still treat
// a property as duplicate if the names and signatures match.

因此他们添加了一个 hack 以实现向后兼容性。

您必须添加自己的处理才能获得所需的行为。也许，Fastreflect 可以提供帮助。

Answer 2

这是因为Class1<T>.Prop1 和Class2.Prop1 不是同一个属性...在Class1<T> 中，属性的类型为T，而在Class2 中，它的类型为string。

Class2 只是泛型类Class1<T> 的一种实现，但可能还有其他的……考虑一下：

class Class3 : Class1<int>
{
    protected override int Prop1 { get; set; }
    protected override string Prop2 { get; set; }
}

如果你认为Class2.Prop1与Class1<T>.Prop1具有相同的属性，Class3.Prop1与Class1<T>.Prop1具有相同的属性，那么Class2.Prop1也与Class3.Prop1相同，显然没有意义：一个是string 类型，另一个是int 类型...