C#通过反射实现动态属性访问器

利用反射，我们可以创建一个动态的属性访问器（Dynamic Property Accessor），允许我们在运行时访问和修改对象的属性
为什么要动态访问

为什么不直接访问，而用动态访问？

• 直接访问实用于：
  
  
  
  • 编译时就知道要访问的属性
    
  • 寻求最高性能的场景
    
  • 简单的属性访问
    
  
  
• 动态访问实用于：
  
  
  
  • 运行时才确定要访问的属性
    
  • 必要通用处置处罚逻辑的场景
    
  • 框架开发
    
  • 设置驱动的数据处置处罚
    
  • 动态数据映射和转换
    
  
  

动态访问固然性能略低，但提供了更大的机动性和通用性，特别得当开发框架和通用工具
完备样例

1. using System.Reflection;
2. using System.Text;
4. public class DynamicPropertyAccessor<T> where T : class
5. {
6.     private readonly Dictionary<string, PropertyInfo> _properties;
8.     public DynamicPropertyAccessor()
9.     {
10.         _properties = typeof(T).GetProperties()
11.             .ToDictionary(p => p.Name, StringComparer.OrdinalIgnoreCase);
12.     }
14.     public bool HasProperty(string propertyName)
15.     {
16.         return _properties.ContainsKey(propertyName);
17.     }
19.     public IEnumerable<string> GetPropertyNames()
20.     {
21.         return _properties.Keys;
22.     }
24.     public Type GetPropertyType(string propertyName)
25.     {
26.         if (_properties.TryGetValue(propertyName, out PropertyInfo propInfo))
27.         {
28.             return propInfo.PropertyType;
29.         }
30.         throw new ArgumentException($"Property '{propertyName}' not found in type {typeof(T).Name}.");
31.     }
33.     public bool IsPropertyWritable(string propertyName)
34.     {
35.         if (_properties.TryGetValue(propertyName, out PropertyInfo propInfo))
36.         {
37.             return propInfo.CanWrite;
38.         }
39.         throw new ArgumentException($"Property '{propertyName}' not found in type {typeof(T).Name}.");
40.     }
42.     public object GetPropertyValue(T obj, string propertyName)
43.     {
44.         if (obj == null)
45.             throw new ArgumentNullException(nameof(obj));
47.         if (string.IsNullOrEmpty(propertyName))
48.             throw new ArgumentNullException(nameof(propertyName));
50.         if (_properties.TryGetValue(propertyName, out PropertyInfo propInfo))
51.         {
52.             try
53.             {
54.                 return propInfo.GetValue(obj);
55.             }
56.             catch (Exception ex)
57.             {
58.                 throw new InvalidOperationException($"Error getting value for property {propertyName}", ex);
59.             }
60.         }
61.         throw new ArgumentException($"Property '{propertyName}' not found in type {typeof(T).Name}.");
62.     }
64.     public void SetPropertyValue(T obj, string propertyName, object value)
65.     {
66.         if (obj == null)
67.             throw new ArgumentNullException(nameof(obj));
69.         if (string.IsNullOrEmpty(propertyName))
70.             throw new ArgumentNullException(nameof(propertyName));
72.         if (_properties.TryGetValue(propertyName, out PropertyInfo propInfo))
73.         {
74.             try
75.             {
76.                 if (!propInfo.CanWrite)
77.                 {
78.                     throw new InvalidOperationException($"Property {propertyName} is read-only.");
79.                 }
81.                 if (value != null && !propInfo.PropertyType.IsAssignableFrom(value.GetType()))
82.                 {
83.                     value = Convert.ChangeType(value, propInfo.PropertyType);
84.                 }
86.                 propInfo.SetValue(obj, value);
87.             }
88.             catch (Exception ex)
89.             {
90.                 throw new InvalidOperationException(
91.                     $"Error setting value for property {propertyName}. Expected type: {propInfo.PropertyType.Name}", ex);
92.             }
93.         }
94.         else
95.         {
96.             throw new ArgumentException($"Property '{propertyName}' not found in type {typeof(T).Name}.");
97.         }
98.     }
100.     public void BatchUpdateProperties(T entity, Dictionary<string, object> updates)
101.     {
102.         if (entity == null)
103.             throw new ArgumentNullException(nameof(entity));
104.         if (updates == null)
105.             throw new ArgumentNullException(nameof(updates));
107.         foreach (var update in updates)
108.         {
109.             SetPropertyValue(entity, update.Key, update.Value);
110.         }
111.     }
113.     public string Export(IEnumerable<T> items, string[] propertiesToExport)
114.     {
115.         if (items == null)
116.             throw new ArgumentNullException(nameof(items));
117.         if (propertiesToExport == null || propertiesToExport.Length == 0)
118.             throw new ArgumentException("No properties specified for export", nameof(propertiesToExport));
120.         var txt = new StringBuilder();
121.         foreach (var item in items)
122.         {
123.             var values = propertiesToExport
124.                 .Select(prop => GetPropertyValue(item, prop)?.ToString())
125.                 .ToList();
126.             txt.AppendLine(string.Join(",", values));
127.         }
128.         return txt.ToString();
129.     }
131.     public void CopyMatchingProperties<TTarget>(T source, TTarget target) where TTarget : class
132.     {
133.         if (source == null)
134.             throw new ArgumentNullException(nameof(source));
135.         if (target == null)
136.             throw new ArgumentNullException(nameof(target));
138.         var targetAccessor = new DynamicPropertyAccessor<TTarget>();
140.         foreach (var prop in _properties.Values)
141.         {
142.             try
143.             {
144.                 if (targetAccessor.HasProperty(prop.Name))
145.                 {
146.                     var value = GetPropertyValue(source, prop.Name);
147.                     targetAccessor.SetPropertyValue(target, prop.Name, value);
148.                 }
149.             }
150.             catch (Exception ex)
151.             {
152.                 // 可以选择记录日志
153.                 Console.WriteLine($"Error copying property {prop.Name}: {ex.Message}");
154.             }
155.         }
156.     }
158.     public (bool IsValid, List<string> MissingProperties) ValidateRequiredProperties(
159.         T entity,
160.         string[] requiredProperties)
161.     {
162.         if (entity == null)
163.             throw new ArgumentNullException(nameof(entity));
165.         if (requiredProperties == null || requiredProperties.Length == 0)
166.             return (true, new List<string>());
168.         var missingProperties = new List<string>();
170.         foreach (var propName in requiredProperties)
171.         {
172.             if (!HasProperty(propName))
173.             {
174.                 missingProperties.Add($"Property '{propName}' does not exist");
175.                 continue;
176.             }
178.             var value = GetPropertyValue(entity, propName);
179.             if (value == null)
180.             {
181.                 missingProperties.Add(propName);
182.             }
183.         }
185.         return (missingProperties.Count == 0, missingProperties);
186.     }
188. }
190. class Product
191. {
192.     public int Id { get; set; }
193.     public string Name { get; set; }
194.     public decimal Price { get; set; }
195. }
197. internal class Program
198. {
199.     static void Main(string[] args)
200.     {
201.         try
202.         {
203.             var accessor = new DynamicPropertyAccessor<Product>();
204.             var product = new Product { Id = 1, Name = "Laptop", Price = 999.99m };
205.             var product2 = new Product();
207.             // 测试属性访问
208.             Console.WriteLine($"产品名称: {accessor.GetPropertyValue(product, "Name")}");
209.             accessor.SetPropertyValue(product, "Price", 1099.99m);
210.             Console.WriteLine($"更新后的价格: {product.Price}");
212.             // 测试属性验证
213.             var requiredNameField = new[] { "Name" };
214.             var (isValidName, missingName) = accessor.ValidateRequiredProperties(product, requiredNameField);
215.             if (!isValidName)
216.             {
217.                 Console.WriteLine($"缺少必要字段: {string.Join(", ", missingName)}");
218.             }
220.             var requiredSizeField = new[] { "Size" };
221.             var (isValidSize, missingSize) = accessor.ValidateRequiredProperties(product, requiredSizeField);
222.             if (!isValidSize)
223.             {
224.                 Console.WriteLine($"缺少必要字段: {string.Join(", ", missingSize)}");
225.             }
227.             // 测试批量更新
228.             var updates = new Dictionary<string, object>
229.             {
230.                 { "Name", "New Laptop" },
231.                 { "Price", 1299.99m }
232.             };
233.             accessor.BatchUpdateProperties(product, updates);
234.             Console.WriteLine($"批量更新后 - 名称: {product.Name}, 价格: {product.Price}");
236.             // 测试属性复制
237.             accessor.CopyMatchingProperties(product, product2);
238.             Console.WriteLine($"复制后的产品 - Id: {product2.Id}, Name: {product2.Name}, Price: {product2.Price}");
240.             // 测试导出
241.             var products = new List<Product> { product, product2 };
242.             var export = accessor.Export(products, new[] { "Id", "Name", "Price" });
243.             Console.WriteLine("\n导出结果:");
244.             Console.WriteLine(export);
246.             // 测试属性信息
247.             Console.WriteLine("\n属性信息:");
248.             foreach (var propName in accessor.GetPropertyNames())
249.             {
250.                 var propType = accessor.GetPropertyType(propName);
251.                 var isWritable = accessor.IsPropertyWritable(propName);
252.                 Console.WriteLine($"属性: {propName}, 类型: {propType.Name}, 可写: {isWritable}");
253.             }
254.         }
255.         catch (Exception ex)
256.         {
257.             Console.WriteLine($"发生错误: {ex.Message}");
258.         }
260.         Console.WriteLine("\n按任意键退出...");
261.         Console.ReadKey();
262.     }
263. }

复制代码

运行结果

1. 产品名称: Laptop
2. 更新后的价格: 1099.99
3. 缺少必要字段: Property 'Size' does not exist
4. 批量更新后 - 名称: New Laptop, 价格: 1299.99
5. 复制后的产品 - Id: 1, Name: New Laptop, Price: 1299.99
7. 导出结果:
8. 1,New Laptop,1299.99
9. 1,New Laptop,1299.99
11. 属性信息:
12. 属性: Id, 类型: Int32, 可写: True
13. 属性: Name, 类型: String, 可写: True
14. 属性: Price, 类型: Decimal, 可写: True

复制代码

应用场景举例

这种实现特别实用于：

• 必要动态处置处罚对象属性的场景
  
• ORM（对象关系映射）框架
  
• 通用数据转换工具
  
• 设置管理体系
  
• 单元测试框架
  

利用场景：

• 数据映射：在差别对象之间复制属性值
  
• 通用数据处置处罚：处置处罚具有动态属性的对象
  
• 设置体系：动态读写设置值
  
• 序列化/反序列化：动态处置处罚对象属性
  

数据映射和转换

1. // 不同对象间的属性复制
2. public class SourceDTO
3. {
4.     public string Name { get; set; }
5.     public decimal Price { get; set; }
6. }
8. public class TargetEntity
9. {
10.     public string Name { get; set; }
11.     public decimal Price { get; set; }
12. }
13. internal class Program
14. {
15.     static void Main(string[] args)
16.     {      
17.         var dto = new SourceDTO { Name = "Test", Price = 100 };
18.         var entity = new TargetEntity();
19.         var sAccessor = new DynamicPropertyAccessor<SourceDTO>();
20.         var tAccessor = new DynamicPropertyAccessor<TargetEntity>();
21.         sAccessor.CopyMatchingProperties(dto, entity);
23.         var targetEntities = new List<TargetEntity> { entity };
24.         var export = tAccessor.Export(targetEntities, new[] { "Name", "Price" });
25.         Console.WriteLine("\n导出结果:");
26.         Console.WriteLine(export);
27.         Console.ReadKey();
28.     }
29. }

复制代码

1. 导出结果:
2. Test,100

复制代码

属性复制

类似数据映射和转换，见完备样例
设置体系

1. // 从配置文件动态设置对象属性
2. public class AppSettings
3. {
4.     public string DatabaseConnection { get; set; }
5.     public int Timeout { get; set; }
6.     public bool EnableLogging { get; set; }
7. }
8. internal class Program
9. {
10.     // 模拟从配置文件读取配置
11.     public static Dictionary<string, object> LoadConfigurationFromFile()
12.     {
13.         return new Dictionary<string, object>
14.             {
15.                 { "DatabaseConnection", "Config.ConnectionString" },
16.                 { "Timeout", 30 },
17.                 { "EnableLogging", true },
18.             };
19.     }
20.     static void Main(string[] args)
21.     {
22.         // 使用示例
23.         var settings = new AppSettings();
24.         var configValues = LoadConfigurationFromFile(); // 返回 Dictionary<string, object>
25.         var accessor = new DynamicPropertyAccessor<AppSettings>();
26.         accessor.BatchUpdateProperties(settings, configValues);
28.         var targetEntities = new List<AppSettings> { settings };
29.         var export = accessor.Export(targetEntities, new[] { "DatabaseConnection", "Timeout", "EnableLogging" });
30.         Console.WriteLine("\n导出结果:");
31.         Console.WriteLine(export);
32.         Console.ReadKey();
33.     }
34. }

复制代码

数据导入导出

1. // CSV数据导入
2. public void ImportFromCsv(string csvData)
3. {
4.     var accessor = new DynamicPropertyAccessor<Product>();
5.     foreach (var line in csvData.Split('\n'))
6.     {
7.         var values = line.Split(',');
8.         var product = new Product();
9.         accessor.SetPropertyValue(product, "Name", values[0]);
10.         accessor.SetPropertyValue(product, "Price", decimal.Parse(values[1]));
11.         // 保存产品...
12.     }
13. }

复制代码

数据验证

见完备样例
通用数据处置处罚工具

1. // 通用数据比较器
2. public bool CompareObjects<T>(T obj1, T obj2, string[] propertiesToCompare) where T : class
3. {
4.     var accessor = new DynamicPropertyAccessor<T>();
5.     foreach (var prop in propertiesToCompare)
6.     {
7.         var value1 = accessor.GetPropertyValue(obj1, prop);
8.         var value2 = accessor.GetPropertyValue(obj2, prop);
9.         if (!Equals(value1, value2)) return false;
10.     }
11.     return true;
12. }

复制代码

特点

• 机动性：可以在运行时动态访问和修改对象属性
  
• 通用性：实用于任何范例的对象
  
• 性能优化：缓存属性信息，克制重复反射
  
• 功能丰富：提供批量操纵、验证、复制等功能
  

注意事项

• 性能思量：固然有缓存，但反射操纵仍比直接访问慢
  
• 属性可访问性：注意属性的读写权限
  

参考

• C#: 利用反射和泛型的高级本领