1. 项目概述：为什么我们需要深入理解 PropertyInfo？

在C#开发中，尤其是涉及数据映射、序列化、反射构建通用工具或实现动态数据绑定的场景里，我们经常面临一个看似简单却至关重要的任务：如何动态地获取一个实体类（Entity Class）所有属性的名称（Name）和其当前的值（Value）？这个需求远不止于简单的“获取”，它背后关联着ORM框架如何将数据库记录映射为对象、Web API如何将JSON反序列化为模型、以及我们如何编写不依赖于具体类型的通用数据处理代码。

PropertyInfo就是 .NET 反射（Reflection）机制中，专门用于描述和操作类型属性的核心类。它像一把“万能钥匙”，允许我们在运行时（Runtime）而非编译时（Compile Time）探查和操纵对象的内部结构。直接使用object.PropertyName是静态的、强类型的，而通过PropertyInfo则是动态的、弱类型的，这为我们打开了编写灵活、可扩展代码的大门。

举个例子，假设你正在开发一个通用的数据导出到Excel的功能。用户可能选择导出“订单”类，也可能导出“用户”类。你不可能为每一个实体类都写一套几乎相同的导出逻辑。这时，通过PropertyInfo动态获取选中实体类的所有属性名（作为Excel表头）和每个实例的属性值（作为Excel行数据），一套代码就能适配所有实体类。再比如，实现一个简单的对象对比器（Object Comparer），用于比较两个同类型对象哪些属性值发生了变化，PropertyInfo也是不可或缺的工具。

因此，掌握PropertyInfo来获取属性名和值，是C#中级开发者向高级进阶必须跨越的一道门槛。它不仅是技术点，更是一种编程思维的转变——从“写死”的逻辑转向“动态”的架构。接下来，我将结合十多年的实战经验，从原理到细节，从基础操作到高阶避坑，为你彻底拆解这个主题。

2. 核心原理与基础操作拆解

2.1 反射与 PropertyInfo 的本质

要理解PropertyInfo，必须先理解 .NET 的反射机制。你可以把程序集（.dll 或 .exe）想象成一个装满元数据（Metadata）的“黑盒”。元数据详细描述了其中定义的所有类型（类、结构体、枚举等）、类型的成员（方法、属性、字段等）以及这些成员的详细信息（名称、类型、修饰符等）。反射，就是程序在运行时“照镜子”或“拆解黑盒”的能力，它允许我们读取和操作这些元数据。

PropertyInfo类位于System.Reflection命名空间下，它是MemberInfo的一个派生类，专门封装了关于属性（Property）的元数据。一个PropertyInfo对象代表一个特定的属性。它本身不存储属性的值，而是存储关于这个属性的“描述信息”，例如：

• 名称（Name）：属性的标识符。
• 属性类型（PropertyType）：该属性是string、int还是某个自定义类。
• 可读性（CanRead）：是否定义了get访问器。
• 可写性（CanWrite）：是否定义了set访问器。
• 声明类型（DeclaringType）：定义该属性的类型。
• 修饰符（如 IsPublic, IsStatic）：访问级别和是否静态。

获取属性值，实际上是调用该属性底层get访问器所关联的方法。PropertyInfo.GetValue方法就是触发这个调用的入口。

2.2 获取类型与 PropertyInfo 集合

操作的第一步是获取目标类型的Type对象。Type类是反射的入口点。

// 假设我们有一个实体类 public class Product { public int Id { get; set; } public string Name { get; set; } public decimal Price { get; set; } private string InternalCode { get; set; } // 私有属性 } // 获取 Type 对象的几种常见方式： // 1. 使用 typeof 运算符（编译时已知类型） Type productType = typeof(Product); // 2. 通过对象实例获取（运行时已知实例） Product myProduct = new Product { Id = 1, Name = "Laptop" }; Type typeFromInstance = myProduct.GetType(); // 3. 通过类型名称字符串动态获取（常用于插件式架构） string typeName = "MyNamespace.Product, MyAssembly"; Type typeByName = Type.GetType(typeName); // 需要程序集限定名

拿到Type对象后，就可以获取其属性信息了。Type.GetProperties方法是最常用的。

// 获取所有公共实例属性（最常用） PropertyInfo[] allPublicProperties = productType.GetProperties(); // 获取所有属性（包括非公共的、静态的），需要指定 BindingFlags // BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic PropertyInfo[] allProperties = productType.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); // 获取特定名称的属性 PropertyInfo idProperty = productType.GetProperty("Id");

注意：GetProperties()默认只返回公共的实例属性。如果你需要获取私有或静态属性，必须显式使用BindingFlags。BindingFlags的组合使用需要小心，例如同时指定Public和NonPublic才能获取所有访问级别的属性。

2.3 获取属性名称与属性值

获取属性名非常简单，直接访问PropertyInfo.Name属性即可。

获取属性值则需要一个对象实例，因为值是属于特定对象的。使用PropertyInfo.GetValue方法。

Product product = new Product { Id = 101, Name = "Wireless Mouse", Price = 29.99m }; // 获取 Id 属性的 PropertyInfo PropertyInfo idPropInfo = product.GetType().GetProperty("Id"); // 获取属性名 string propertyName = idPropInfo.Name; // "Id" // 获取该实例下此属性的值 object idValue = idPropInfo.GetValue(product); // 101 (装箱为 object) // 获取 Name 属性的值 PropertyInfo namePropInfo = product.GetType().GetProperty("Name"); object nameValue = namePropInfo.GetValue(product); // "Wireless Mouse" // 遍历所有公共属性并打印名称和值 foreach (PropertyInfo prop in product.GetType().GetProperties()) { string name = prop.Name; object value = prop.GetValue(product); Console.WriteLine($"{name}: {value}"); } // 输出： // Id: 101 // Name: Wireless Mouse // Price: 29.99

这里有一个关键点：GetValue返回的是object类型。这是因为在编译时，PropertyInfo并不知道它操作的具体属性是什么类型，所以返回值必须是最通用的object。如果你需要强类型操作，必须进行类型转换或使用泛型等高级技巧（后续会讲到）。

2.4 处理索引器属性

普通属性我们熟悉了，但还有一种特殊的属性：索引器（Indexer）。它的PropertyInfo获取方式略有不同。

public class SampleCollection { private string[] arr = new string[100]; // 索引器定义 public string this[int i] { get { return arr[i]; } set { arr[i] = value; } } } // 获取索引器的 PropertyInfo // 索引器在C#中的默认名称为 "Item"，除非用 [IndexerName("...")] 特性指定 SampleCollection col = new SampleCollection(); col[0] = "Hello"; Type collectionType = typeof(SampleCollection); // 通过指定参数类型来获取索引器属性 PropertyInfo indexerProperty = collectionType.GetProperty("Item", new Type[] { typeof(int) }); if (indexerProperty != null) { // 获取索引器值时，需要提供索引参数 object indexerValue = indexerProperty.GetValue(col, new object[] { 0 }); Console.WriteLine(indexerValue); // 输出: Hello }

实操心得：在编写通用代码时，如果无法确定目标类型是否有索引器，或者索引器参数类型是什么，可以通过Type.GetProperties()获取所有属性后，检查每个PropertyInfo的GetIndexParameters()方法返回的数组长度。长度大于0的，就是索引器属性。处理索引器时，务必向GetValue传递正确数量和类型的索引参数数组，否则会抛出TargetParameterCountException。

3. 高级应用与性能优化实战

掌握了基础，我们就可以解决更复杂的实际问题，并开始关注至关重要的性能问题。反射虽然强大，但其性能开销也是众所周知的。

3.1 复杂场景：嵌套对象、集合与空值处理

现实中的实体类很少像Product那么简单。它们可能包含嵌套对象、集合，并且属性值可能为null。

场景一：嵌套对象属性值的获取假设Order类包含一个Customer类型的属性。

public class Customer { public string Name { get; set; } } public class Order { public int OrderId { get; set; } public Customer Buyer { get; set; } } Order order = new Order { OrderId = 1, Buyer = new Customer { Name = "Alice" } }; PropertyInfo buyerProp = typeof(Order).GetProperty("Buyer"); object buyerValue = buyerProp.GetValue(order); // 这是一个 Customer 对象 // 如果我们想进一步获取 Buyer 的 Name if (buyerValue != null) { Type customerType = buyerValue.GetType(); PropertyInfo nameProp = customerType.GetProperty("Name"); object nameValue = nameProp.GetValue(buyerValue); // “Alice” }

场景二：处理集合类型属性例如，一个Order有多个OrderItem。

public class Order { public List<OrderItem> Items { get; set; } = new List<OrderItem>(); } public class OrderItem { public string ProductName { get; set; } public int Quantity { get; set; } } Order order = new Order(); order.Items.Add(new OrderItem { ProductName = "Book", Quantity = 2 }); PropertyInfo itemsProp = typeof(Order).GetProperty("Items"); object itemsValue = itemsProp.GetValue(order); // 这是一个 List<OrderItem> 对象 if (itemsValue is System.Collections.IEnumerable enumerable) { foreach (var item in enumerable) { // 对每个 item 再进行反射操作... Type itemType = item.GetType(); var nameProp = itemType.GetProperty("ProductName"); Console.WriteLine(nameProp.GetValue(item)); } }

场景三：空值（Null）与可空值类型（Nullable）这是反射中最容易出错的地方之一。

public class Entity { public string? OptionalDescription { get; set; } // 可为空的引用类型 public int? NullableInt { get; set; } // 可空值类型 Nullable<int> } Entity entity = new Entity(); // 两个属性都为 null PropertyInfo descProp = typeof(Entity).GetProperty("OptionalDescription"); object descValue = descProp.GetValue(entity); // 返回 null，这是安全的 PropertyInfo intProp = typeof(Entity).GetProperty("NullableInt"); object intValue = intProp.GetValue(entity); // 也返回 null // 问题：如何区分一个返回的 null 是引用类型的 null，还是 Nullable<T> 的 HasValue 为 false？ // 对于可空值类型，GetValue 返回的是 `Nullable<T>` 这个结构体被装箱后的对象。 // 如果 HasValue 为 false，这个装箱后的对象就是 null。 // 所以，从 object 结果上，你无法直接区分。需要在获取前检查属性类型。 if (intProp.PropertyType.IsGenericType && intProp.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>)) { // 这是一个可空值类型 // 如果 intValue 为 null，表示数据库中的 DBNull 或未赋值 }

避坑指南：在处理可能为null的嵌套对象属性时，务必在调用下一层GetValue或GetProperty前进行判空。否则会抛出NullReferenceException。对于可空值类型，直接判断GetValue返回的object是否为null即可，无需拆箱。

3.2 性能瓶颈与优化策略：表达式树与委托

直接使用PropertyInfo.GetValue在循环或高频调用中会成为性能瓶颈，因为它涉及方法查找、权限检查、参数打包/解包等一系列开销。一个常见的优化策略是：将反射操作“编译”成高效的委托。

方案一：使用Func<object, object>委托我们可以为每个属性的 getter 创建一个委托。

public static Func<object, object> CreatePropertyGetter(PropertyInfo property) { // 参数：对象实例 var instance = Expression.Parameter(typeof(object), "instance"); // 将 object 转换为实际类型 var castInstance = Expression.Convert(instance, property.DeclaringType); // 访问属性 var propertyAccess = Expression.Property(castInstance, property); // 将属性值转换为 object var castResult = Expression.Convert(propertyAccess, typeof(object)); // 构建 lambda 表达式并编译为委托 var lambda = Expression.Lambda<Func<object, object>>(castResult, instance); return lambda.Compile(); } // 使用优化后的方式 Product product = new Product { Id = 1 }; PropertyInfo idProp = typeof(Product).GetProperty("Id"); var idGetter = CreatePropertyGetter(idProp); // 一次性编译 // 后续百万次调用，性能接近直接属性访问 for (int i = 0; i < 1_000_000; i++) { object value = idGetter(product); }

方案二：使用泛型委托Func<T, object>如果知道具体类型，可以进一步优化，避免Expression.Convert的开销。

public static Func<T, object> CreatePropertyGetter<T>(PropertyInfo property) { var instance = Expression.Parameter(typeof(T), "instance"); var propertyAccess = Expression.Property(instance, property); var castResult = Expression.Convert(propertyAccess, typeof(object)); var lambda = Expression.Lambda<Func<T, object>>(castResult, instance); return lambda.Compile(); } // 使用 var idGetterGeneric = CreatePropertyGetter<Product>(idProp); object value = idGetterGeneric(product);

方案三：直接使用Delegate.CreateDelegate(适用于无参属性Getter)对于简单的get访问器，有更直接的优化方法。

public static Func<object, object> CreatePropertyGetterFast(PropertyInfo property) { // 获取属性的 get 方法 MethodInfo getMethod = property.GetGetMethod(); // 创建开放委托（Open Delegate），第一个参数是实例 var delegateType = typeof(Func<,>).MakeGenericType(property.DeclaringType, property.PropertyType); Delegate concreteDelegate = Delegate.CreateDelegate(delegateType, null, getMethod); // 再包装一层，将输入 object 转换并调用 Func<object, object> result = instance => concreteDelegate.DynamicInvoke(instance); return result; } // 注意：此方法简化了错误处理，实际使用需考虑DeclaringType为null（静态属性）等情况。

性能实测对比：在一个获取100万次属性值的简单测试中，直接属性访问（p.Id）耗时约5ms，使用编译后的委托（方案二）耗时约30ms，而使用原生PropertyInfo.GetValue耗时可能超过1000ms。差距高达两个数量级。因此，在需要高性能反射的场景（如序列化库、ORM框架的核心映射层），预编译委托是标准做法。

3.3 利用缓存避免重复反射

另一个重要的优化点是缓存。我们不应该在每次需要属性信息时都去调用GetProperties或GetProperty，尤其是在循环中。

using System.Collections.Concurrent; public static class PropertyCache<T> { private static readonly ConcurrentDictionary<string, PropertyInfo> _propertyCache = new ConcurrentDictionary<string, PropertyInfo>(); private static PropertyInfo[] _allProperties; public static PropertyInfo[] GetAllProperties() { if (_allProperties == null) { _allProperties = typeof(T).GetProperties(); } return _allProperties; } public static PropertyInfo GetProperty(string name) { return _propertyCache.GetOrAdd(name, n => typeof(T).GetProperty(n)); } } // 使用缓存 var props = PropertyCache<Product>.GetAllProperties(); // 第一次反射，后续直接返回数组 var idProp = PropertyCache<Product>.GetProperty("Id"); // 第一次反射后缓存

结合委托编译和缓存，可以构建一个高性能的属性访问器工厂。

public static class PropertyAccessor { private static readonly ConcurrentDictionary<PropertyInfo, Func<object, object>> _getterCache = new ConcurrentDictionary<PropertyInfo, Func<object, object>>(); public static Func<object, object> GetCachedGetter(PropertyInfo property) { return _getterCache.GetOrAdd(property, CreatePropertyGetter); } private static Func<object, object> CreatePropertyGetter(PropertyInfo property) { // 使用上文方案一的表达式树创建委托 // ... 实现代码同上 ... } } // 终极用法：一次编译，永久高速访问 Product p = new Product(); PropertyInfo pi = PropertyCache<Product>.GetProperty("Name"); Func<object, object> getter = PropertyAccessor.GetCachedGetter(pi); string name = (string)getter(p); // 极速访问

4. 实战案例：构建一个简易对象映射器

现在，让我们综合运用以上所有知识，构建一个实用的工具：一个简易的“对象到字典”映射器。这在日志记录、API响应格式化、动态UI数据绑定等场景非常有用。

4.1 需求分析与设计

目标：编写一个泛型方法ToDictionary<T>，将任意对象T的所有公共实例属性转换成一个Dictionary<string, object>，其中 Key 是属性名，Value 是属性值。要求：

1. 处理嵌套对象（将其值直接放入字典，或进行递归展开？本例选择直接放入）。
2. 处理集合属性（将其作为IEnumerable放入字典）。
3. 正确处理空值。
4. 有基本的性能考虑（使用缓存）。

4.2 核心实现代码

using System.Collections.Concurrent; using System.Linq.Expressions; using System.Reflection; public static class ObjectDictionaryMapper { // 缓存类型对应的属性Getter委托列表 private static readonly ConcurrentDictionary<Type, List<PropertyGetter>> _propertyGettersCache = new ConcurrentDictionary<Type, List<PropertyGetter>>(); private class PropertyGetter { public string Name { get; set; } public Func<object, object> GetValue { get; set; } } public static Dictionary<string, object> ToDictionary(object obj) { if (obj == null) throw new ArgumentNullException(nameof(obj)); var type = obj.GetType(); var getters = _propertyGettersCache.GetOrAdd(type, t => { var properties = t.GetProperties(BindingFlags.Public | BindingFlags.Instance) .Where(p => p.CanRead); // 只读属性也可以获取值 var list = new List<PropertyGetter>(); foreach (var prop in properties) { // 跳过索引器 if (prop.GetIndexParameters().Length > 0) continue; list.Add(new PropertyGetter { Name = prop.Name, GetValue = CreatePropertyGetter(prop) // 使用编译后的委托 }); } return list; }); var dictionary = new Dictionary<string, object>(); foreach (var getter in getters) { object value = getter.GetValue(obj); dictionary[getter.Name] = value; // 这里 value 可能是 null，也可能是嵌套对象或集合 } return dictionary; } private static Func<object, object> CreatePropertyGetter(PropertyInfo property) { var instance = Expression.Parameter(typeof(object), "instance"); var castInstance = Expression.Convert(instance, property.DeclaringType); var propertyAccess = Expression.Property(castInstance, property); var castResult = Expression.Convert(propertyAccess, typeof(object)); var lambda = Expression.Lambda<Func<object, object>>(castResult, instance); return lambda.Compile(); } }

4.3 使用示例与扩展

// 测试类 public class Order { public int Id { get; set; } public string OrderNumber { get; set; } public Customer Customer { get; set; } public List<OrderItem> Items { get; set; } public DateTime? ShippedDate { get; set; } } // 准备数据 var order = new Order { Id = 1001, OrderNumber = "ORD-2023-001", Customer = new Customer { Name = "Bob" }, Items = new List<OrderItem> { new OrderItem { ProductName = "Keyboard", Quantity = 1 }, new OrderItem { ProductName = "Mouse", Quantity = 2 } }, ShippedDate = null }; // 转换为字典 var dict = ObjectDictionaryMapper.ToDictionary(order); // 输出结果 foreach (var kvp in dict) { Console.WriteLine($"{kvp.Key}: {kvp.Value}"); } // 输出类似： // Id: 1001 // OrderNumber: ORD-2023-001 // Customer: MyNamespace.Customer (ToString的结果) // Items: System.Collections.Generic.List`1[MyNamespace.OrderItem] // ShippedDate:

当前实现的局限性：

1. 嵌套对象（如Customer）和集合（如Items）只是简单调用了ToString()，在字典中显示的是类型名，这可能不是我们想要的。
2. 没有处理循环引用（A 引用 B，B 又引用 A），会导致栈溢出。

扩展方向：

• 深度转换：修改ToDictionary，使其递归地将嵌套对象也转换为字典。需要添加一个HashSet<object>参数来跟踪已处理的对象，防止循环引用。
• 选择性转换：通过特性（Attribute）标记需要忽略的属性，或者只转换标记了的属性。
• 处理特定类型：为DateTime、Guid等类型提供自定义的字符串格式化。
• 线程安全优化：当前的缓存是线程安全的（ConcurrentDictionary），但委托的创建过程如果非常耗时，在极高并发下首次访问可能造成重复创建。可以考虑使用Lazy<T>包装委托的创建过程。

5. 常见陷阱、疑难排查与最佳实践

即使掌握了原理和优化，在实际使用PropertyInfo时，依然会遇到不少坑。这里记录了一些典型问题和解决方案。

5.1 典型异常与处理方案

5.2 值类型与装箱拆箱的坑

当操作结构体（struct）的属性时，需要特别注意装箱（Boxing）问题。

public struct Point { public int X { get; set; } public int Y { get; set; } } Point p = new Point { X = 10, Y = 20 }; Type pointType = typeof(Point); PropertyInfo xProp = pointType.GetProperty("X"); // 错误做法：这会导致 p 被装箱，修改的是装箱后的副本，原 p 不变。 object boxedP = p; xProp.SetValue(boxedP, 30); Console.WriteLine(p.X); // 输出 10，未改变！ // 正确做法：通过引用装箱 object boxedPRef = p; // 装箱 xProp.SetValue(boxedPRef, 30); // 修改装箱副本 p = (Point)boxedPRef; // 拆箱并赋值回原变量 Console.WriteLine(p.X); // 输出 30

对于GetValue，值类型属性返回的是装箱后的object。频繁操作会导致大量堆内存分配，影响性能。这也是为什么高性能场景推荐使用编译后的泛型委托，它可以避免不必要的装箱。

5.3 属性与字段的混淆

初学者容易混淆属性（Property）和字段（Field）。PropertyInfo用于属性，而字段的信息由FieldInfo类表示。它们通过不同的方法获取：

// 获取字段 FieldInfo[] fields = typeof(MyClass).GetFields(); // 获取属性 PropertyInfo[] properties = typeof(MyClass).GetProperties();

关键区别：属性本质上是方法（getter/setter）的语法糖，可能有逻辑；字段是直接的数据存储。在序列化、数据绑定等场景中，通常使用属性而非公共字段，因为属性提供了更好的封装和控制（如验证逻辑）。

5.4 最佳实践总结

1. 明确需求，避免滥用反射：反射会降低性能、增加代码复杂度、并可能破坏封装。如果编译时就能确定类型，优先使用强类型。反射应留给插件系统、序列化、ORM、动态代理等真正需要动态性的场景。
2. 缓存，缓存，再缓存：将Type、PropertyInfo数组、编译后的委托等所有可以缓存的信息都缓存起来。使用ConcurrentDictionary或MemoryCache是常见选择。
3. 关注性能，使用表达式树或Delegate.CreateDelegate：对于高频调用的属性访问，一定要将反射调用转换为委托调用。表达式树（Expression）提供了灵活且相对安全的编译方式。
4. 做好错误处理和边界检查：总是检查GetProperty返回的PropertyInfo是否为null。处理嵌套属性时层层判空。考虑索引器、静态属性、只读/只写属性等特殊情况。
5. 考虑使用现成的库：对于复杂的对象映射、序列化需求，优先考虑使用成熟的库，如AutoMapper（对象映射）、Newtonsoft.Json或System.Text.Json（序列化）。它们已经解决了性能、循环引用、复杂类型处理等绝大多数问题，并且经过了千锤百炼的测试。
6. 单元测试：反射代码容易因类型变化而断裂。为你的反射工具类编写充分的单元测试，覆盖各种边界情况（空值、值类型、嵌套类型、循环引用、索引器等）。

通过以上五个部分的详细拆解，我们从PropertyInfo的基本用法走到了高性能实战和复杂场景处理。记住，反射是一把强大的双刃剑，理解其原理并遵循最佳实践，才能让它在你手中安全、高效地发挥作用，赋能于那些需要高度灵活性和动态性的C#应用程序模块。