嘿，我来帮你搞定这个动态Selector的需求！你想让用户自由选择任意数量、任意顺序的数据库列，然后在EF LINQ里生成对应的Select语句，代替硬编码的new { x.id, x.age }对吧？

这里的关键是EF需要表达式树来解析成SQL，直接用反射访问属性是不行的（EF没法把反射调用转换成SQL），所以我们得手动构建表达式树来生成动态的Selector。下面给你两种实用的实现方式：

方式一：生成动态匿名类型（推荐，EF友好） #

这种方式会创建一个和用户选择列匹配的动态匿名类型，EF能完美解析它并生成对应的SELECT语句。我们写一个扩展方法来封装逻辑：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;

public static class QueryableDynamicExtensions
{
    // 扩展方法：接收IQueryable<T>和列名列表，返回动态类型的查询
    public static IQueryable<dynamic> SelectDynamic<T>(this IQueryable<T> source, IEnumerable<string> columnNames)
    {
        // 构建参数表达式：就是lambda里的"x"
        var parameter = Expression.Parameter(typeof(T), "x");
        
        // 为每个列名生成属性绑定表达式
        var propertyBindings = columnNames
            .Select(columnName =>
            {
                // 获取实体类对应的属性（忽略大小写）
                var targetProperty = typeof(T).GetProperty(
                    columnName, 
                    BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
                
                if (targetProperty == null)
                    throw new ArgumentException($"找不到实体类型 {typeof(T).Name} 中的属性 {columnName}");
                
                // 生成 x.PropertyName 的表达式
                var propertyAccess = Expression.Property(parameter, targetProperty);
                // 绑定到动态类型的属性上
                return Expression.Bind(targetProperty, propertyAccess);
            })
            .ToList();
        
        // 创建动态匿名类型
        var dynamicType = CreateDynamicAnonymousType(propertyBindings.Select(b => b.Member as PropertyInfo));
        // 生成动态类型的初始化表达式：new DynamicType { Property1 = x.Property1, ... }
        var initExpression = Expression.MemberInit(
            Expression.New(dynamicType.GetConstructor(Type.EmptyTypes)), 
            propertyBindings);
        
        // 构建完整的lambda表达式：x => new DynamicType { ... }
        var selectorLambda = Expression.Lambda<Func<T, dynamic>>(initExpression, parameter);
        
        // 应用Select并返回结果
        return source.Select(selectorLambda);
    }

    // 私有方法：动态创建匿名类型
    private static Type CreateDynamicAnonymousType(IEnumerable<PropertyInfo> properties)
    {
        // 动态构建程序集、模块和类型
        var assemblyName = new AssemblyName($"DynamicAnon_{Guid.NewGuid():N}");
        var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
        var moduleBuilder = assemblyBuilder.DefineDynamicModule("DynamicAnonModule");
        
        // 定义类型：公共、可序列化的类
        var typeBuilder = moduleBuilder.DefineType(
            $"AnonType_{Guid.NewGuid():N}", 
            TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Serializable);
        
        // 为每个属性生成字段和get/set方法
        foreach (var prop in properties)
        {
            // 私有字段
            var fieldBuilder = typeBuilder.DefineField($"_{prop.Name}", prop.PropertyType, FieldAttributes.Private);
            // 公共属性
            var propertyBuilder = typeBuilder.DefineProperty(prop.Name, PropertyAttributes.None, prop.PropertyType, null);
            
            // Get方法
            var getMethod = typeBuilder.DefineMethod(
                $"get_{prop.Name}", 
                MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, 
                prop.PropertyType, 
                Type.EmptyTypes);
            var getIl = getMethod.GetILGenerator();
            getIl.Emit(OpCodes.Ldarg_0);
            getIl.Emit(OpCodes.Ldfld, fieldBuilder);
            getIl.Emit(OpCodes.Ret);
            
            // Set方法
            var setMethod = typeBuilder.DefineMethod(
                $"set_{prop.Name}", 
                MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, 
                null, 
                new[] { prop.PropertyType });
            var setIl = setMethod.GetILGenerator();
            setIl.Emit(OpCodes.Ldarg_0);
            setIl.Emit(OpCodes.Ldarg_1);
            setIl.Emit(OpCodes.Stfld, fieldBuilder);
            setIl.Emit(OpCodes.Ret);
            
            // 绑定属性的get/set方法
            propertyBuilder.SetGetMethod(getMethod);
            propertyBuilder.SetSetMethod(setMethod);
        }
        
        // 添加无参构造函数
        typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes)
            .GetILGenerator().Emit(OpCodes.Ret);
        
        // 创建并返回类型
        return typeBuilder.CreateType();
    }
}

使用示例 #

// 用户选择的列列表
var selectedColumns = new List<string> { "id", "age", "address" };
// 应用动态Select
var dynamicResult = dbContext.YourEntities.SelectDynamic(selectedColumns).ToList();

方式二：返回ExpandoObject（灵活但EF解析稍差） #

如果不需要强类型的结果，也可以返回ExpandoObject，它是.NET的动态类型，方便后续通过键值对访问属性：

public static IQueryable<ExpandoObject> SelectToExpando<T>(this IQueryable<T> source, IEnumerable<string> columnNames)
{
    var parameter = Expression.Parameter(typeof(T), "x");
    
    var bindings = columnNames
        .Select(columnName =>
        {
            var property = typeof(T).GetProperty(
                columnName, 
                BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
            
            if (property == null)
                throw new ArgumentException($"找不到实体类型 {typeof(T).Name} 中的属性 {columnName}");
            
            // 绑定到ExpandoObject的Item属性
            return Expression.Bind(
                typeof(ExpandoObject).GetProperty("Item"),
                Expression.Constant(columnName),
                Expression.Property(parameter, property));
        });
    
    var initExpression = Expression.MemberInit(Expression.New(typeof(ExpandoObject)), bindings);
    var lambda = Expression.Lambda<Func<T, ExpandoObject>>(initExpression, parameter);
    
    return source.Select(lambda);
}

使用示例 #

var result = dbContext.YourEntities.SelectToExpando(selectedColumns).ToList();
// 访问属性：
foreach (var item in result)
{
    var id = item["id"];
    var age = item["age"];
}

注意事项 #

• 列名要和实体类的属性名匹配（代码里加了IgnoreCase，所以大小写不敏感），如果列名不存在会抛出异常，建议根据实际情况添加错误处理。
• 动态生成的匿名类型在EF Core和EF6中都能被正确解析成SQL，只会查询用户选择的列，不会查询所有列。
• 如果使用EF Core，也可以考虑使用Select结合Dictionary<string, object>，但表达式树的方式更高效，因为EF能直接解析。

备注：内容来源于stack exchange，提问作者Hossein POURAKBAR