如何更快将DataTable转换为POCO？性能优化方案探讨

你的现有实现性能瓶颈主要在重复反射调用、低效的实例化和通用类型转换的额外开销上，以下是几个针对性的优化方案，按性能提升幅度排序：

1. 缓存反射元数据+预编译实例化委托 #

每次循环都调用GetType().GetProperties()和Activator.CreateInstance<T>是最大的性能杀手，把这些信息缓存起来，只在第一次转换时获取：

// 缓存类型的构造委托和属性-列映射
private static readonly Dictionary<Type, (Func<T> InstanceCreator, Dictionary<string, PropertyInfo> PropMap)> _typeCache = new();

public static List<T> OptimizedMapper<T>(DataTable dt) where T : new()
{
    // 第一次调用时缓存元数据
    if (!_typeCache.TryGetValue(typeof(T), out var cacheEntry))
    {
        // 缓存无参构造函数的委托，比Activator.CreateInstance快
        var ctor = typeof(T).GetConstructor(Type.EmptyTypes);
        var instanceCreator = Expression.Lambda<Func<T>>(Expression.New(ctor)).Compile();
        
        // 缓存属性与列名的映射（只保留DataTable中存在的列）
        var propMap = typeof(T).GetProperties()
            .Where(p => dt.Columns.Contains(p.Name))
            .ToDictionary(p => p.Name);
            
        _typeCache[typeof(T)] = (instanceCreator, propMap);
        cacheEntry = (instanceCreator, propMap);
    }

    var list = new List<T>(dt.Rows.Count); // 预分配容量，避免多次扩容
    var columnIndices = dt.Columns.Cast<DataColumn>()
        .ToDictionary(col => col.ColumnName, col => col.Ordinal); // 预存列索引，直接按索引取值

    foreach (DataRow row in dt.Rows)
    {
        T obj = cacheEntry.InstanceCreator();
        
        foreach (var kvp in cacheEntry.PropMap)
        {
            string propName = kvp.Key;
            PropertyInfo prop = kvp.Value;
            
            // 按索引直接取行数据，比按列名查找快
            object value = row[columnIndices[propName]];
            if (value != DBNull.Value)
            {
                // 针对常见类型直接转换，避免Convert.ChangeType的开销
                prop.SetValue(obj, ConvertValue(value, prop.PropertyType));
            }
            else
            {
                prop.SetValue(obj, null);
            }
        }
        
        list.Add(obj);
    }
    
    return list;
}

// 针对常见类型做直接转换，减少装箱拆箱和通用转换的开销
private static object ConvertValue(object value, Type targetType)
{
    if (targetType == typeof(int)) return (int)value;
    if (targetType == typeof(string)) return value.ToString();
    if (targetType == typeof(DateTime)) return (DateTime)value;
    if (targetType == typeof(bool)) return (bool)value;
    if (targetType == typeof(long)) return (long)value;
    if (targetType == typeof(decimal)) return (decimal)value;
    // 其他类型可以继续补充， fallback到Convert.ChangeType
    return Convert.ChangeType(value, targetType);
}

2. 进阶：使用表达式树生成完整映射委托 #

表达式树可以把整个映射逻辑编译成委托，性能接近手写硬编码的映射，是反射方案中最快的选择之一：

private static readonly Dictionary<Type, Func<DataRow, T>> _rowMapperCache = new();

public static List<T> ExpressionTreeMapper<T>(DataTable dt) where T : new()
{
    if (!_rowMapperCache.TryGetValue(typeof(T), out var mapper))
    {
        mapper = CreateRowMapper<T>(dt);
        _rowMapperCache[typeof(T)] = mapper;
    }

    var list = new List<T>(dt.Rows.Count);
    foreach (DataRow row in dt.Rows)
    {
        list.Add(mapper(row));
    }
    return list;
}

private static Func<DataRow, T> CreateRowMapper<T>(DataTable dt) where T : new()
{
    var rowParam = Expression.Parameter(typeof(DataRow), "row");
    var objVar = Expression.Variable(typeof(T), "obj");
    var assignObj = Expression.Assign(objVar, Expression.New(typeof(T)));
    
    var bindings = new List<Expression>();
    bindings.Add(assignObj);
    
    var props = typeof(T).GetProperties().Where(p => dt.Columns.Contains(p.Name));
    foreach (var prop in props)
    {
        var columnName = prop.Name;
        var columnIndex = dt.Columns[columnName].Ordinal;
        
        // 获取行数据：row[columnIndex]
        var rowAccess = Expression.Property(rowParam, "Item", Expression.Constant(columnIndex));
        
        // 判断是否为DBNull
        var isNotNull = Expression.NotEqual(rowAccess, Expression.Constant(DBNull.Value));
        
        // 转换值到属性类型
        var convertedValue = Expression.Condition(
            isNotNull,
            Expression.Convert(rowAccess, prop.PropertyType),
            Expression.Constant(null, prop.PropertyType)
        );
        
        // 赋值给属性：obj.Prop = value
        var assignProp = Expression.Assign(Expression.Property(objVar, prop), convertedValue);
        bindings.Add(assignProp);
    }
    
    // 返回obj
    bindings.Add(objVar);
    
    var block = Expression.Block(new[] { objVar }, bindings);
    return Expression.Lambda<Func<DataRow, T>>(block, rowParam).Compile();
}

3. 其他小优化点 #

• 预分配List容量：创建List<T>时传入dt.Rows.Count，避免内部数组多次扩容的开销。
• 避免不必要的null赋值：如果属性是值类型且不允许为null，可跳过null赋值逻辑（需根据业务需求调整）。
• 并行处理（谨慎使用）：仅当DataRow数量极大且为CPU密集场景时，可尝试Parallel.ForEach，但需注意线程安全，IO密集场景反而可能降低性能。

内容的提问来源于stack exchange，提问作者onhax