企业官网建设流程全解析

告别繁琐赋值：C#反射与泛型实现DataTable与实体类的高效互转

在.NET开发中，DataTable与实体类之间的转换是每个开发者都会遇到的常见任务。传统的手动赋值方式不仅耗时耗力，还容易出错，尤其是在处理复杂数据结构或频繁变更的业务需求时。本文将介绍如何利用C#的反射机制和泛型特性，构建一套高效、通用的转换方案，彻底告别重复劳动。

1. 为什么需要自动化转换？

在日常开发中，我们经常遇到以下场景：

• 从数据库查询结果（DataTable）转换为强类型实体集合
• 将实体集合导出为DataTable用于报表生成或数据交换
• 与遗留系统交互时处理大量数据映射
• 快速原型开发中需要频繁调整数据结构

手动处理这些转换不仅效率低下，还会带来以下问题：

1. 代码冗余：相似的赋值代码在项目中反复出现
2. 维护困难：字段变更需要修改多处转换逻辑
3. 错误风险：类型不匹配或空值处理不当导致运行时异常
4. 可读性差：大量样板代码掩盖了业务逻辑的核心

// 传统手动转换示例 - 每个属性都需要显式赋值 Person person = new Person(); person.Id = Convert.ToInt32(row["Id"]); person.Name = row["Name"].ToString(); person.Age = row["Age"] != DBNull.Value ? Convert.ToInt32(row["Age"]) : (int?)null;

2. 反射与泛型的完美结合

2.1 基础转换实现

利用反射和泛型，我们可以创建一个通用的扩展方法，适用于任何实体类型：

public static List<T> ToEntities<T>(this DataTable table) where T : new() { List<T> entities = new List<T>(); PropertyInfo[] properties = typeof(T).GetProperties(); foreach (DataRow row in table.Rows) { T entity = new T(); foreach (PropertyInfo prop in properties) { if (table.Columns.Contains(prop.Name) && row[prop.Name] != DBNull.Value) { prop.SetValue(entity, row[prop.Name]); } } entities.Add(entity); } return entities; }

关键点解析：

• typeof(T).GetProperties()获取目标类型的所有属性
• DataTable.Columns.Contains检查属性名是否存在于数据列中
• PropertyInfo.SetValue动态设置属性值

2.2 反向转换：实体集合转DataTable

同样原理，我们可以实现反向转换：

public static DataTable ToDataTable<T>(this IEnumerable<T> entities) { DataTable table = new DataTable(); PropertyInfo[] properties = typeof(T).GetProperties(); // 创建列 foreach (PropertyInfo prop in properties) { table.Columns.Add(prop.Name, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType); } // 填充数据 foreach (T entity in entities) { DataRow row = table.NewRow(); foreach (PropertyInfo prop in properties) { row[prop.Name] = prop.GetValue(entity) ?? DBNull.Value; } table.Rows.Add(row); } return table; }

3. 处理可空类型的进阶技巧

可空类型（Nullable）是实际开发中最容易出错的环节之一。下面介绍几种处理方案：

3.1 自动识别可空属性

// 改进后的属性设置逻辑 if (table.Columns.Contains(prop.Name)) { object value = row[prop.Name]; Type propType = prop.PropertyType; if (value == DBNull.Value) { if (propType.IsGenericType && propType.GetGenericTypeDefinition() == typeof(Nullable<>)) { prop.SetValue(entity, null); } } else { prop.SetValue(entity, Convert.ChangeType(value, Nullable.GetUnderlyingType(propType) ?? propType)); } }

3.2 类型转换器集成

对于复杂类型转换，可以集成TypeConverter：

TypeConverter converter = TypeDescriptor.GetConverter(prop.PropertyType); if (converter.CanConvertFrom(value.GetType())) { prop.SetValue(entity, converter.ConvertFrom(value)); }

3.3 自定义属性映射

通过自定义特性实现列名映射：

[AttributeUsage(AttributeTargets.Property)] public class ColumnMappingAttribute : Attribute { public string ColumnName { get; } public ColumnMappingAttribute(string columnName) { ColumnName = columnName; } } // 使用示例 public class Person { [ColumnMapping("PersonID")] public int Id { get; set; } [ColumnMapping("FullName")] public string Name { get; set; } }

4. 性能优化与最佳实践

反射虽然强大，但性能开销不容忽视。以下是几种优化策略：

4.1 缓存反射结果

private static readonly ConcurrentDictionary<Type, PropertyInfo[]> _propertyCache = new(); public static PropertyInfo[] GetCachedProperties(Type type) { return _propertyCache.GetOrAdd(type, t => t.GetProperties()); }

4.2 表达式树编译

对于高频调用的场景，可以使用表达式树编译委托：

public static Func<DataRow, T> CreateEntityCreator<T>() where T : new() { ParameterExpression rowParam = Expression.Parameter(typeof(DataRow), "row"); List<MemberBinding> bindings = new List<MemberBinding>(); foreach (PropertyInfo prop in typeof(T).GetProperties()) { MethodInfo getItemMethod = typeof(DataRowExtensions).GetMethod("Field", new[] { typeof(DataRow), typeof(string) }); MethodInfo genericGetItem = getItemMethod.MakeGenericMethod(prop.PropertyType); MethodCallExpression getValue = Expression.Call( null, genericGetItem, rowParam, Expression.Constant(prop.Name)); bindings.Add(Expression.Bind(prop, getValue)); } MemberInitExpression init = Expression.MemberInit( Expression.New(typeof(T)), bindings); return Expression.Lambda<Func<DataRow, T>>(init, rowParam).Compile(); }

4.3 基准测试对比

下表展示了不同实现方式的性能对比（转换1000条记录）：

5. 实际应用中的陷阱与解决方案

5.1 枚举类型处理

if (prop.PropertyType.IsEnum) { prop.SetValue(entity, Enum.ToObject(prop.PropertyType, value)); } else if (Nullable.GetUnderlyingType(prop.PropertyType)?.IsEnum == true) { Type enumType = Nullable.GetUnderlyingType(prop.PropertyType); prop.SetValue(entity, Enum.ToObject(enumType, value)); }

5.2 复杂对象序列化

对于嵌套对象，可以考虑JSON序列化：

if (prop.PropertyType.IsClass && prop.PropertyType != typeof(string)) { string json = JsonConvert.SerializeObject(value); prop.SetValue(entity, JsonConvert.DeserializeObject(json, prop.PropertyType)); }

5.3 字段大小写不匹配

// 不区分大小写的列名查找 DataColumn column = table.Columns.Cast<DataColumn>() .FirstOrDefault(c => string.Equals(c.ColumnName, prop.Name, StringComparison.OrdinalIgnoreCase));

6. 完整解决方案示例

以下是一个经过生产验证的完整实现：

public static class DataTableExtensions { private static readonly ConcurrentDictionary<Type, PropertyInfo[]> PropertyCache = new(); private static readonly ConcurrentDictionary<Type, Func<DataRow, object>> EntityCreators = new(); public static List<T> ToEntities<T>(this DataTable table) where T : new() { if (table == null || table.Rows.Count == 0) return new List<T>(); Func<DataRow, object> creator = EntityCreators.GetOrAdd(typeof(T), type => CompileEntityCreator<T>()); PropertyInfo[] properties = GetCachedProperties(typeof(T)); List<T> result = new List<T>(table.Rows.Count); foreach (DataRow row in table.Rows) { result.Add((T)creator(row)); } return result; } private static Func<DataRow, object> CompileEntityCreator<T>() where T : new() { ParameterExpression rowParam = Expression.Parameter(typeof(DataRow), "row"); List<MemberBinding> bindings = new List<MemberBinding>(); foreach (PropertyInfo prop in GetCachedProperties(typeof(T))) { string columnName = GetColumnName(prop); MethodInfo fieldMethod = typeof(DataRowExtensions).GetMethod("Field", new[] { typeof(DataRow), typeof(string) }); MethodInfo genericField = fieldMethod.MakeGenericMethod(prop.PropertyType); MethodCallExpression getValue = Expression.Call(null, genericField, rowParam, Expression.Constant(columnName)); if (prop.PropertyType.IsEnum) { MethodInfo toObjectMethod = typeof(Enum).GetMethod("ToObject", new[] { typeof(Type), typeof(object) }); getValue = Expression.Call(toObjectMethod, Expression.Constant(prop.PropertyType), getValue); } bindings.Add(Expression.Bind(prop, getValue)); } MemberInitExpression init = Expression.MemberInit(Expression.New(typeof(T)), bindings); return Expression.Lambda<Func<DataRow, object>>(init, rowParam).Compile(); } private static string GetColumnName(PropertyInfo prop) { ColumnMappingAttribute attr = prop.GetCustomAttribute<ColumnMappingAttribute>(); return attr?.ColumnName ?? prop.Name; } private static PropertyInfo[] GetCachedProperties(Type type) { return PropertyCache.GetOrAdd(type, t => t.GetProperties(BindingFlags.Public | BindingFlags.Instance)); } }

7. 扩展应用场景

7.1 批量操作支持

public static async Task BulkInsertAsync<T>(this DbConnection connection, IEnumerable<T> entities, string tableName) { using var bulkCopy = new SqlBulkCopy(connection as SqlConnection); bulkCopy.DestinationTableName = tableName; DataTable table = entities.ToDataTable(); await bulkCopy.WriteToServerAsync(table); }

7.2 动态查询构建

public static IQueryable<T> WhereDynamic<T>(this IQueryable<T> query, DataTable filters) { foreach (DataRow row in filters.Rows) { string propertyName = row["Property"].ToString(); object value = row["Value"]; string operator = row["Operator"].ToString(); ParameterExpression param = Expression.Parameter(typeof(T), "x"); MemberExpression property = Expression.Property(param, propertyName); ConstantExpression constant = Expression.Constant(value); Expression condition = operator switch { "==" => Expression.Equal(property, constant), ">" => Expression.GreaterThan(property, constant), // 其他操作符... }; Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(condition, param); query = query.Where(lambda); } return query; }

8. 单元测试建议

为确保转换逻辑的可靠性，建议编写以下测试用例：

[Test] public void Should_Convert_DataTable_To_Entities_With_Nullable_Properties() { // 准备测试数据 DataTable table = new DataTable(); table.Columns.Add("Id", typeof(int)); table.Columns.Add("Name", typeof(string)); table.Columns.Add("Age", typeof(int)); table.Rows.Add(1, "Alice", 30); table.Rows.Add(2, DBNull.Value, DBNull.Value); // 执行转换 var result = table.ToEntities<Person>(); // 验证结果 Assert.AreEqual(2, result.Count); Assert.IsNull(result[1].Name); Assert.IsNull(result[1].Age); } [Test] public void Should_Handle_Column_Name_Mapping() { // 准备测试数据 DataTable table = new DataTable(); table.Columns.Add("PersonID", typeof(int)); table.Columns.Add("FullName", typeof(string)); table.Rows.Add(1, "Bob"); // 执行转换 var result = table.ToEntities<Person>(); // 验证结果 Assert.AreEqual(1, result[0].Id); Assert.AreEqual("Bob", result[0].Name); }

9. 替代方案比较

除了反射方案，还有其他几种常见的数据转换方法：

10. 实际项目中的经验分享

在金融行业数据导入模块中，我们最初使用了手动赋值的方式处理几十种不同的报表格式。随着业务增长，每次新增报表都需要编写大量重复的转换代码，维护成本急剧上升。后来我们重构为基于反射的通用转换器后：

• 新报表支持时间从2天缩短到2小时
• 代码量减少了70%
• 统一了空值处理逻辑，数据质量问题下降90%
• 通过缓存优化后，性能仅比手动方式低15%

特别在处理银行交易数据时，经常会遇到字段变更（如"客户ID"改为"客户编号"），以前需要修改多处代码，现在只需调整实体类的映射特性即可。