未使用 BindingFlag.Default 从 GetType().GetFields 获取字段

Question

我正在使用 Reflection 类来获取某个对象内的所有字段。 然而，我的问题是，当字段位于普通类内时，它可以完美工作，例如：

class test
{
   string test1 = string.Empty;
   string test2 = string.Empty;
}

这里我同时得到 test1 和 test2，我的问题是我使用抽象，因此组合了几个类。

我得到类似的信息：

class test3 : test2
{
   string test4 = string.Empty;
   string test5 = string.Empty;
}

class test2 : test1
{
   string test2 = string.Empty;
   string test3 = string.Empty;
}
class test1
{
   string test0 = string.Empty;
   string test1 = string.Empty;
}

但是当我运行它时，我没有从 GetType().GetFields(BindingFlag.Default) 获取字段。

这些字段中的每个字段都有一个属性，get; set; 附加到它。 当我运行代码时，我得到的属性一直返回到 test1，但不是实际的字段。

这是我试图获取字段的代码：

FieldInfo[] fields = Obj.GetType().GetFields(BindingFlags.Default);
foreach (FieldInfo field in fields)

我也尝试过：

FieldInfo[] fields = Obj.GetType().GetFields(BindingFlags.Public 
                                             | BindingFlags.Instance 
                                             | BindingFlags.NonPublic 
                                             | BindingFlags.Static);

我对属性使用相同的代码：

PropertyInfo[] properties = Obj.GetType().GetProperties(BindingFlags.Public 
                                             | BindingFlags.Instance 
                                             | BindingFlags.NonPublic 
                                             | BindingFlags.Static);

foreach (PropertyInfo property in properties)

有什么想法为什么我从抽象类获取属性而不是字段？

Answer 1

编辑：要获取基本类型的私有成员，您必须：

typeof(T).BaseType.GetFields(...)

再次编辑：Win。

2013 年 3 月 22 日编辑：使用 Concat 而不是 Union。 由于我们指定 BindingFlags.DeclaredOnly 并且类型的 BaseType 不能等于其自身，因此不需要 Union 并且成本更高。

public static IEnumerable<FieldInfo> GetAllFields(Type t)
{
    if (t == null)
        return Enumerable.Empty<FieldInfo>();

    BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | 
                         BindingFlags.Static | BindingFlags.Instance | 
                         BindingFlags.DeclaredOnly;
    return t.GetFields(flags).Concat(GetAllFields(t.BaseType));
}

Answer 2

继承另一个类型的类型无法看到该其他类型的私有部分，它可以看到受保护的、内部的和公共的部分。 考虑以下代码：

class A
{
    // note that this field is private
    string PrivateString = string.Empty;
    // protected field
    protected string ProtectedString = string.Empty;
}

class B : A { }

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("B Fields:");
        B b = new B();
        b.GetType()
            .GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
            .ToList()
            .ForEach(f => Console.WriteLine(f.Name));

        Console.WriteLine("A Fields:");
        A a = new A();
        a.GetType()
            .GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
            .ToList()
            .ForEach(f => Console.WriteLine(f.Name));

    }
}

该程序的输出如下：

B Fields:
ProtectedString
A Fields:
PrivateString
ProtectedString

因此，类型 A 有两个字段； PrivateString 和 ProtectedString。 类型 B 有一个； ProtectedString，它继承自A。 如果您希望通过类型 B“到达”PrivateString，则需要导航到其基本类型 (b.GetType().BaseType）。

但请注意，即使类型 B 报告有一个名为 ProtectedString 的字段，该字段仍然没有在 B 中声明； 它在 A 中声明。 可以通过将 BindingFlags.DeclaredOnly 添加到上述示例程序中的 GetFields 调用来检查这一点； GetFields 不会为 B 返回任何字段，为 A 返回两个字段。

转换为您的代码示例，这意味着类型 test3 不包含字段 test2 和 test3，因为它们是类型 test3 私有的。 code>test2 （恐怕字段名称和类型名称的相似性使这句话有些混乱）.a

Answer 3

您可以使用此扩展方法递归遍历类型的继承层次结构一直到对象，有效地返回该类型的所有字段及其所有祖先：（

public static class ReflectionExtensions
{
    public static IList<FieldInfo> GetAllFields(this Type type, BindingFlags flags)
    {
        if(type == typeof(Object)) return new List<FieldInfo>();

        var list = type.BaseType.GetAllFields(flags);
        // in order to avoid duplicates, force BindingFlags.DeclaredOnly
        list.AddRange(type.GetFields(flags | BindingFlags.DeclaredOnly));
        return list;
    }
}

未经测试，YMMV）

Answer 4

属性是继承的，而字段则不是。 受保护的字段对后代类可见，但不能被它们继承。 换句话说，后代类实际上具有其基类的属性，但它只是能够看到字段。

Answer 5

如果您只想要属性和字段的名称，请使用

private static IEnumerable<string > GetAllFieldsAndProperties(Type t)
{
  if (t == null)
    return Enumerable.Empty<string>();

  BindingFlags flags = BindingFlags.Public 
    | BindingFlags.NonPublic 
    | BindingFlags.Static 
    | BindingFlags.Instance 
    | BindingFlags.DeclaredOnly;
  return t.GetFields(flags).Select(x=>x.Name)
    .Union(GetAllFieldsAndProperties(t.BaseType))
    .Union(t.GetProperties(flags).Select(x=>x.Name));
}

Answer 6

所有类型字段的枚举，包括基类中的私有成员。

public static IEnumerable<FieldInfo> EnumerateFields(this Type type, BindingFlags flags) =>
   type.BaseType?.EnumerateFields(flags)
       .Concat(type.GetFields(flags | BindingFlags.DeclaredOnly)) ??
   type.EnumerateFields(flags);

Answer 7

根据萨姆和史蒂夫的回答，这对我有用：

---

public static List<Variance> DetailedCompare<T>(this T val1, T val2)
    {
        try
        {
            List<Variance> variances = new List<Variance>();

            BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic |
                                 BindingFlags.Static | BindingFlags.Instance |
                                 BindingFlags.DeclaredOnly;
            FieldInfo[] fi = val1.GetType().GetFields(flags);

            foreach (FieldInfo f in fi)
            {
                var previousValue = f.GetValue(val1);
                var newValue = f.GetValue(val2); 

                if (!Equals(previousValue, newValue))
                {
                    Variance v = new Variance
                    {
                        Prop = f.Name,
                        PreviousValue = previousValue,
                        NewValue = newValue
                    };
                    variances.Add(v);
                }
            }
            return variances;
        }
        catch
        {
            return null;
        }
    }