通常，反射用于动态获取对象的类型、属性和方法等信息。今天带你玩转反射，来汇总一下反射的各种常见操作，捡漏看看有没有你不知道的。
获取类型的成员Type 类的 GetMembers 方法用来获取该类型的所有成员，包括方法和属性，可通过 BindingFlags 标志来筛选这些成员。
using System; using System.Reflection; using System.Linq; public class Program { public static voidMain() { var members = typeof(object).GetMembers(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance); foreach (var member in members) { Console.WriteLine($"{member.Name} is a {member.MemberType}"); } } }输出：
GetType is a Method GetHashCode is a Method ToString is a Method Equals is a Method ReferenceEquals is a Method .ctor is a ConstructorGetMembers 方法也可以不传 BindingFlags，默认返回的是所有公开的成员。
获取并调用对象的方法Type 类型的 GetMethod 方法用来获取该类型的 MethodInfo，然后可通过 MethodInfo 动态调用该方法。
对于非静态方法，需要传递对应的实例作为参数，示例：
class Program { public static void Main() { var str = "hello"; var method = str.GetType() .GetMethod("Substring", new[] {typeof(int), typeof(int)}); var result = method.Invoke(str, new object[] {0, 4}); // 相当于 str.Substring(0, 4) Console.WriteLine(result); // 输出：hell } }对于静态方法，则对象参数传空，示例：
var method = typeof(Math).GetMethod("Exp"); // 相当于 Math.Exp(2) var result = method.Invoke(null, new object[] {2}); Console.WriteLine(result); // 输出(e^2)：7.38905609893065如果是泛型方法，则还需要通过泛型参数来创建泛型方法，示例：
class Program { public static void Main() { // 反射调用泛型方法 MethodInfo method1 = typeof(Sample).GetMethod("GenericMethod"); MethodInfo generic1 = method1.MakeGenericMethod(typeof(string)); generic1.Invoke(sample, null); // 反射调用静态泛型方法 MethodInfo method2 = typeof(Sample).GetMethod("StaticMethod"); MethodInfo generic2 = method2.MakeGenericMethod(typeof(string)); generic2.Invoke(null, null); } } public class Sample { public void GenericMethod<T>() { //... } public static void StaticMethod<T>() { //... } } 创建一个类型的实例使用反射动态创建一个类型的实例有多种种方式。最简单的一种是用 new() 条件声明。
使用 new 条件声明如果在一个方法内需要动态创建一个实例，可以直接使用 new 条件声明，例如：
T GetInstance<T>() where T : new() { T instance = newT(); return instance; }但这种方式适用场景有限，比如不适用于构造函数带参数的类型。
使用 Activator 类使用 Activator 类动态创建一个类的实例是最常见的做法，示例：
Type type = typeof(BigInteger); object result = Activator.CreateInstance(type); Console.WriteLine(result); // 输出：0 result = Activator.CreateInstance(type, 123); Console.WriteLine(result); // 输出：123动态创建泛类型实例，需要先创建开放泛型（如List<>），再根据泛型参数转换为具象泛型（如List<string>），示例：
// 先创建开放泛型 Type openType = typeof(List<>); // 再创建具象泛型 Type[] tArgs = { typeof(string) }; Type target = openType.MakeGenericType(tArgs); // 最后创建泛型实例 List<string> result = (List<string>)Activator.CreateInstance(target);如果你不知道什么是开放泛型和具象泛型，请看本文最后一节。
使用构造器反射也可以通过反射构造器的方式动态创建类的实例，比上面使用 Activator 类要稍稍麻烦些，但性能要好些。示例：
ConstructorInfo c = typeof(T).GetConstructor(new[] { typeof(string) }); if (c == null) throw new InvalidOperationException("..."); T instance = (T)c.Invoke(new object[] { "test" }); 使用 FormatterServices 类如果你想创建某个类的实例的时候不执行构造函数和属性初始化，可以使用 FormatterServices 的 GetUninitializedObject 方法。示例：
class Program { static void Main() { MyClass instance = (MyClass)FormatterServices.GetUninitializedObject(typeof(MyClass)); Console.WriteLine(instance.MyProperty1); // 输出：0 Console.WriteLine(instance.MyProperty2); // 输出：0 } } public class MyClass { public MyClass(int val) { MyProperty1 = val < 1 ? 1 : val; } public int MyProperty1 { get; } public int MyProperty2 { get; set; } = 2; } 获取属性或方法的强类型委托通过反射获取到对象的属性和方法后，如果你想通过强类型的方法来访问或调用，可以在中间加一层委托。这样的好处是有利于封装，调用者可以明确的知道调用时需要传什么参数。 比如下面这个方法，把 Math.Max 方法提取为一个强类型委托：
var tArgs = new Type[] { typeof(int), typeof(int) }; var maxMethod = typeof(Math).GetMethod("Max", tArgs); var strongTypeDelegate = (Func<int, int, int>)Delegate .CreateDelegate(typeof(Func<int, int, int>), null, maxMethod); Console.WriteLine("3 和 5 之间最大的是：{0}", strongTypeDelegate(3, 5)); // 输出：5