无需反射或第三方库，通过字符串列名实现Linq Select列选择

1. 手动构建表达式树（轻量无依赖） #

直接通过Expression API构建Select所需的Lambda表达式，EF Core能将其解析为对应的SQL，性能和强类型写法几乎一致，没有第三方库的额外开销。

代码示例：

public static class ExpressionBuilder
{
    // 构建单个列的Select表达式
    public static Expression<Func<TEntity, object>> BuildSingleColumnSelector<TEntity>(string columnName)
    {
        var parameter = Expression.Parameter(typeof(TEntity), "x");
        // 获取实体的属性/字段
        var property = Expression.PropertyOrField(parameter, columnName);
        // 处理值类型装箱，避免转换错误
        var converted = Expression.Convert(property, typeof(object));
        return Expression.Lambda<Func<TEntity, object>>(converted, parameter);
    }
}

// 使用方式
var targetColumn = "YourColumnName";
var query = _context.Entity
    .Include(x => x.Addresses)
    .Select(ExpressionBuilder.BuildSingleColumnSelector<Entity>(targetColumn));

2. 预编译表达式树缓存（重复调用最优） #

如果需要多次使用相同的列名查询，将构建好的表达式树缓存起来，避免重复构建的开销，性能进一步提升。

代码示例：

public static class CachedExpressionBuilder
{
    private static readonly Dictionary<(Type EntityType, string ColumnName), LambdaExpression> _selectorCache = 
        new Dictionary<(Type, string), LambdaExpression>();

    public static Expression<Func<TEntity, object>> GetCachedSingleColumnSelector<TEntity>(string columnName)
    {
        var cacheKey = (typeof(TEntity), columnName);
        if (_selectorCache.TryGetValue(cacheKey, out var cachedExpr))
        {
            return (Expression<Func<TEntity, object>>)cachedExpr;
        }

        // 构建表达式
        var parameter = Expression.Parameter(typeof(TEntity), "x");
        var property = Expression.PropertyOrField(parameter, columnName);
        var converted = Expression.Convert(property, typeof(object));
        var selector = Expression.Lambda<Func<TEntity, object>>(converted, parameter);

        // 存入缓存
        _selectorCache[cacheKey] = selector;
        return selector;
    }
}

// 使用方式
var query = _context.Entity
    .Include(x => x.Addresses)
    .Select(CachedExpressionBuilder.GetCachedSingleColumnSelector<Entity>(targetColumn));

3. 结合EF Core元数据API（安全高效） #

利用EF Core的Model元数据验证列名的合法性，避免拼写错误导致的运行时异常，同时元数据是EF Core初始化时已加载的，比反射更高效。

代码示例：

public static class MetadataExpressionBuilder
{
    public static Expression<Func<TEntity, object>> BuildSelectorWithValidation<TEntity>(string columnName, DbContext context)
    {
        var entityType = context.Model.FindEntityType(typeof(TEntity));
        var property = entityType.FindProperty(columnName);
        
        if (property == null)
        {
            throw new ArgumentException($"Column '{columnName}' does not exist on entity '{typeof(TEntity).Name}'");
        }

        var parameter = Expression.Parameter(typeof(TEntity), "x");
        var propertyAccess = Expression.Property(parameter, property.Name);
        var converted = Expression.Convert(propertyAccess, typeof(object));
        return Expression.Lambda<Func<TEntity, object>>(converted, parameter);
    }
}

// 使用方式
var query = _context.Entity
    .Include(x => x.Addresses)
    .Select(MetadataExpressionBuilder.BuildSelectorWithValidation<Entity>(targetColumn, _context));

方案优势对比 #

• 比Dynamic.Linq：避免了字符串解析为表达式的额外开销，性能更接近原生强类型写法，且无第三方依赖。
• 比反射：反射是在运行时直接取值（无法被EF Core转换为SQL，会导致全表加载后在内存过滤），而表达式树会被EF Core解析为SQL，仅查询指定列，数据库层面就完成投影，性能差距极大。

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