C# BindingFlags 使用详解

总目录

---

前言

在 C# 编程的世界里，反射（Reflection）是一个强大且灵活的特性，它允许我们在运行时动态地获取和操作类型的信息。而 BindingFlags 枚举类型，作为反射中的核心概念之一，为我们提供了精确控制类型成员查找和操作的能力（通过组合多个标志来指定搜索类型 如字段、方法、属性等成员 的条件）。今天，就让我们深入探讨 BindingFlags 的使用，解锁反射的更多可能性。

---

一、什么是 BindingFlags？

1. 定义

BindingFlags 是一个枚举类型，它定义了一系列的标志，用于指定反射操作的搜索条件。它通过组合多个标志（Flags）来控制反射方法（如 GetFields、GetMethods、GetProperty 等）的行为，使得我们可以灵活地控制要获取或操作的类型成员的范围和特性。

👉 在C#反射编程中，BindingFlags枚举类型是控制成员搜索与操作的核心导航器。

2. 关键特性

• 类型：System.Reflection.BindingFlags （位于 System.Reflection 命名空间）是一个枚举类型。
  • 位标志枚举 ：BindingFlags 是一个 位标志枚举（[Flags]），支持通过按位或（|）组合多个标志。
• 作用：通过组合标志，控制反射方法（如 GetType().GetFields()、GetType().GetMethods() 等）的搜索行为。
• 强制指定：必须同时指定 Instance 或 Static，以及 Public 或 NonPublic，否则会返回空结果。

二、常用 BindingFlags 标志详解

1. 常用标志总览

以下是 BindingFlags 中最常用的标志及其作用：

标志	作用
Public	包括公共成员（如 public 字段、方法、属性）。
NonPublic	包括非公共成员（如 private、protected、internal、protected internal）。
Instance	包括实例成员（非静态成员）。
Static	包括静态成员（类级别的成员）。
DeclaredOnly	仅搜索当前类型声明的成员，不包括继承的成员。
IgnoreCase	忽略成员名称的大小写。
FlattenHierarchy	在静态成员搜索中，包含基类的公共和受保护的静态成员（但不包括私有静态成员）。
CreateInstance	通过反射创建对象实例（需与 InvokeMember 结合使用）。
InvokeMethod	用于调用方法（需与 InvokeMember 结合使用）。
GetField/SetField	用于获取或设置字段值（需与 InvokeMember 结合使用）。
GetProperty/SetProperty	用于获取或设置属性值（需与 InvokeMember 结合使用）。

2. BindingFlags 的常用枚举值

1）IgnoreCase

当指定 IgnoreCase 时，反射在查找成员时会忽略大小写。这在处理不区分大小写的场景中非常有用。

using System;
using System.Reflection;public class TestClass
{public void MyMethod(){Console.WriteLine("MyMethod called.");}
}public class Program
{public static void Main(){Type type = typeof(TestClass);MethodInfo methodInfo = type.GetMethod("mymethod", BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public);if (methodInfo != null){TestClass obj = new TestClass();methodInfo.Invoke(obj, null);}}
}

在这个示例中，即使方法名称是小写的 “mymethod”，通过 BindingFlags.IgnoreCase 也能成功找到并调用 MyMethod 方法。

2）DeclaredOnly

DeclaredOnly 标志用于仅查找在特定类型中声明的成员，而不包括从基类继承的成员。这有助于我们专注于当前类型自身定义的成员。

using System;
using System.Reflection;public class BaseClass
{public void BaseMethod(){Console.WriteLine("BaseMethod called.");}
}public class DerivedClass : BaseClass
{public void DerivedMethod(){Console.WriteLine("DerivedMethod called.");}
}public class Program
{public static void Main(){Type type = typeof(DerivedClass);MethodInfo[] methods = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public);foreach (MethodInfo method in methods){Console.WriteLine(method.Name);}}
}

运行结果将只输出 DerivedMethod，因为 DeclaredOnly 使得我们只查找在 DerivedClass 中声明的方法，而不包括从 BaseClass 继承的方法。

3）Instance 和 Static

Instance 和 Static 分别用于指定查找实例成员或静态成员。在反射操作中，必须明确指定要查找的成员类型。

using System;
using System.Reflection;public class TestClass
{public static void StaticMethod(){Console.WriteLine("StaticMethod called.");}public void InstanceMethod(){Console.WriteLine("InstanceMethod called.");}
}public class Program
{public static void Main(){Type type = typeof(TestClass);// 获取静态方法MethodInfo staticMethod = type.GetMethod("StaticMethod", BindingFlags.Static | BindingFlags.Public);staticMethod.Invoke(null, null);// 获取实例方法MethodInfo instanceMethod = type.GetMethod("InstanceMethod", BindingFlags.Instance | BindingFlags.Public);TestClass obj = new TestClass();instanceMethod.Invoke(obj, null);}
}

这里分别演示了如何获取和调用静态方法与实例方法，通过指定 BindingFlags.Static 或 BindingFlags.Instance 来明确查找范围。

4）Public 和 NonPublic

Public 用于查找公共成员，而 NonPublic 则用于查找非公共成员（包括内部、受保护和私有成员）。这使得我们能够访问类型中不同访问级别的成员。

using System;
using System.Reflection;public class TestClass
{private string privateField;internal int internalProperty { get; set; }protected void ProtectedMethod(){Console.WriteLine("ProtectedMethod called.");}
}public class Program
{public static void Main(){Type type = typeof(TestClass);TestClass obj = new TestClass();// 获取私有字段FieldInfo privateField = type.GetField("privateField", BindingFlags.NonPublic | BindingFlags.Instance);privateField.SetValue(obj, "Private field value");Console.WriteLine(privateField.GetValue(obj));// 获取内部属性PropertyInfo internalProperty = type.GetProperty("internalProperty", BindingFlags.NonPublic | BindingFlags.Instance);internalProperty.SetValue(obj, 42);Console.WriteLine(internalProperty.GetValue(obj));// 获取受保护方法MethodInfo protectedMethod = type.GetMethod("ProtectedMethod", BindingFlags.NonPublic | BindingFlags.Instance);protectedMethod.Invoke(obj, null);}
}

通过 BindingFlags.NonPublic，我们可以访问类中的私有字段、内部属性以及受保护的方法，这在某些需要深入操作类型内部状态的场景中非常有用。

5）FlattenHierarchy

FlattenHierarchy 标志用于在查找静态成员时，沿着类型层次结构向上搜索，包括基类中的公共和受保护静态成员。这对于需要获取整个继承链中的静态成员时非常方便。

using System;
using System.Reflection;public class BaseClass
{public static void BaseStaticMethod(){Console.WriteLine("BaseStaticMethod called.");}
}public class DerivedClass : BaseClass
{public static void DerivedStaticMethod(){Console.WriteLine("DerivedStaticMethod called.");}
}public class Program
{public static void Main(){Type type = typeof(DerivedClass);MethodInfo[] methods = type.GetMethods(BindingFlags.FlattenHierarchy | BindingFlags.Static | BindingFlags.Public);foreach (MethodInfo method in methods){Console.WriteLine(method.Name);}}
}

运行结果将输出 BaseStaticMethod 和 DerivedStaticMethod，因为 FlattenHierarchy 使得我们能够获取基类和派生类中的所有公共静态方法。

3. BindingFlags 的组合使用

BindingFlags 是一个位域枚举，这意味着我们可以使用按位或运算符（|）组合多个枚举值，以指定多个绑定条件。这为我们提供了极大的灵活性，能够满足各种复杂的反射需求。

using System;
using System.Reflection;public class TestClass
{private int privateField;public void PublicMethod(){Console.WriteLine("PublicMethod called.");}private void PrivateMethod(){Console.WriteLine("PrivateMethod called.");}
}public class Program
{public static void Main(){Type type = typeof(TestClass);TestClass obj = new TestClass();// 获取所有实例方法（公共和非公共）MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);foreach (MethodInfo method in methods){Console.WriteLine(method.Name);}// 获取私有字段FieldInfo privateField = type.GetField("privateField", BindingFlags.NonPublic | BindingFlags.Instance);privateField.SetValue(obj, 123);Console.WriteLine(privateField.GetValue(obj));}
}

在这个示例中，我们组合了 BindingFlags.Instance、BindingFlags.Public 和 BindingFlags.NonPublic 来获取类型中的所有实例方法，无论是公共的还是非公共的。同时，也演示了如何获取和操作私有字段。

4. BindingFlags基础配置规则

1）成员类型必选项

必须包含Instance或Static标志中的一个（或同时包含）：

// 获取所有公共实例成员（默认配置）
var publicMembers = type.GetMembers(BindingFlags.Public | BindingFlags.Instance);// 获取私有静态字段
var privateStaticField = type.GetField("_cache", BindingFlags.NonPublic | BindingFlags.Static);

原理：反射引擎需要明确区分实例成员与静态成员的搜索范围。

2）访问权限必选项

必须包含Public或NonPublic标志中的一个（或同时包含）：

// 获取所有非公共方法（含私有和受保护）
var nonPublicMethods = type.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance);// 获取公共静态属性
var staticProperty = type.GetProperty("Logger",BindingFlags.Public | BindingFlags.Static);

注意：若未指定访问权限标志，默认仅搜索公共成员。

5. 典型组合示例

以下是一些典型场景的 BindingFlags 组合：

1）获取公共实例字段

Type type = typeof(MyClass);
// 公共 + 实例
BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance;FieldInfo[] fields = type.GetFields(bindingFlags); 

2）获取私有静态方法

// 非公共 + 静态
BindingFlags bindingFlags = BindingFlags.NonPublic | BindingFlags.Static;MethodInfo method = typeof(MyClass).GetMethod("PrivateMethod", bindingFlags); 

3）获取所有实例属性（包括私有）

// 实例 + 公共 + 非公共
BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;PropertyInfo[] properties = typeof(MyClass).GetProperties(bindingFlags); 

4）获取当前类型声明的所有字段（不包括继承的）

// 仅当前类型声明的字段
BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Public;FieldInfo[] declaredFields = typeof(MyClass).GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); 

5）忽略继承的成员

// 仅当前类型声明的私有实例字段
BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.NonPublic;FieldInfo[] declaredFields = typeof(MyClass).GetFields(bindingFlags); 

6）忽略大小写搜索

// 忽略大小写获取字段 "MyField"
BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public;FieldInfo field = typeof(MyClass).GetField("myfield", bindingFlags);

三、实际应用场景

1. 访问不同条件下的成员

1）访问私有字段

public class MyClass
{private int _privateField;
}// 通过反射获取私有字段
FieldInfo field = typeof(MyClass).GetField("_privateField", BindingFlags.NonPublic | BindingFlags.Instance);// 设置字段值
var instance = new MyClass();
field.SetValue(instance, 42);

2）获取所有属性（包括私有）

public class MyClass
{public string PublicProp { get; set; }private int PrivateProp { get; set; }
}// 获取所有属性（公共 + 私有）
PropertyInfo[] properties = typeof(MyClass).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

3）忽略继承的成员

public class BaseClass
{public string BaseField;
}public class DerivedClass : BaseClass
{public string DerivedField;
}// 仅获取 DerivedClass 自身的字段
FieldInfo[] fields = typeof(DerivedClass).GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
// fields 包含 DerivedField，但不包含 BaseField

2. 动态调用复杂方法

1）调用私有方法

object instance = Activator.CreateInstance(type);
MethodInfo privateMethod = type.GetMethod("InternalProcess",BindingFlags.NonPublic | BindingFlags.Instance);
privateMethod.Invoke(instance, new object[] { data });

2）通过InvokeMember动态操作

// 设置私有静态字段值
type.InvokeMember("_instanceCount", BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Static,null, null, new object[] { 10 });// 调用重载方法（指定参数类型）
object result = type.InvokeMember("Parse",BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static,null, null, new object[] { "2023", CultureInfo.CurrentCulture });

四、使用须知

1. 关键注意事项

1）必须指定实例Instance或静态Static标志

在使用反射查找类型成员时，必须指定 Instance 或 Static 标志之一，否则将返回空数组或 null 值

// 错误：未指定 Instance 或 Static
var fields = type.GetFields(BindingFlags.Public); // 返回空数组// 正确：同时指定 Public 和 Instance
var fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);

2）必须指定公共Public或非公共NonPublic标志

同样，需要指定 Public 或 NonPublic 标志之一来确定要查找的成员的访问级别

// 错误：未指定 Public 或 NonPublic
var fields = type.GetFields(BindingFlags.Instance); // 返回空数组// 正确：同时指定 NonPublic 和 Instance
var fields = type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance);

3）默认绑定规则

如果不指定任何 BindingFlags，默认情况下将查找公共的实例和静态成员。

4）DeclaredOnly 的限制

• 仅搜索当前类型声明的成员，不包括继承的成员。
• 示例：

  public class Base { public string BaseField; }
  public class Derived : Base { public string DerivedField; }// 仅获取 Derived 自身的字段
  var fields = typeof(Derived).GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance); // 只包含 DerivedField
  

5）FlattenHierarchy 的适用场景

• 仅对静态成员有效，且不包含基类的私有静态成员。
• 示例：

  // 获取基类和当前类的公共静态方法
  var methods = typeof(Derived).GetMethods(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static);
  

6）IgnoreCase 的使用场景

• 仅在需要忽略名称大小写时使用，例如处理用户输入的模糊匹配。

2. 性能优化技巧

// 缓存高频访问的MemberInfo对象
private static readonly MethodInfo _cachedMethod = typeof(DataProcessor).GetMethod("Encrypt",BindingFlags.NonPublic | BindingFlags.Instance);// 使用Expression Tree编译动态调用（比纯反射快10倍以上）
var instanceParam = Expression.Parameter(typeof(DataProcessor));
var callExpr = Expression.Call(instanceParam, _cachedMethod);
var lambda = Expression.Lambda<Action<DataProcessor>>(callExpr, instanceParam).Compile();
lambda.Invoke(processor);

3. 常见错误与解决方案

Q1：为什么返回空数组？

• 原因：未正确组合 BindingFlags（如缺少 Instance 或 NonPublic）。
• 解决：确保同时指定 Instance/Static 和 Public/NonPublic。

Q2：访问基类成员失败

• 原因：使用了 DeclaredOnly 标志。
• 解决：移除 DeclaredOnly 或接受仅当前类型的成员。

Q3：调用方法时参数类型不匹配？

• 原因：未指定 ExactBinding 或参数类型不匹配。
• 解决：确保参数类型与方法签名一致，或使用 ExactBinding 强制类型匹配。

4. 总结

• BindingFlags 是反射的“导航仪”，通过组合标志精确控制搜索范围。
• 关键规则：
  1. 必须指定成员类型： Instance 或 Static（或两者）。
  2. 必须指定访问权限： Public 或 NonPublic（或两者）。
  3. 使用 DeclaredOnly 时仅搜索当前类型声明的成员。
• 典型组合：
  • 公共实例成员：BindingFlags.Public | BindingFlags.Instance
  • 私有静态方法：BindingFlags.NonPublic | BindingFlags.Static
  • 所有实例字段：BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic

掌握BindingFlags的配置逻辑可显著提升反射代码的精准度与可靠性。

---

结语

回到目录页：C#/.NET 知识汇总
希望以上内容可以帮助到大家，如文中有不对之处，还请批评指正。