如何在LINQ表达式中定义匿名类型Lambda参数实现按ID分组

你的问题核心是当前动态创建的MyType会导致GroupBy使用自定义类型分组，而非直接绑定原实体的字段值。要解决这个问题，无需在单字段分组场景下创建新类型，直接生成返回单个字段值的Lambda表达式即可适配GroupBy逻辑。

修正思路 #

• 单字段分组：直接构建表达式树返回原实体的指定字段，无需额外创建动态类型，让GroupBy直接以字段值作为分组键
• 多字段分组：保留原有的动态类型创建逻辑，通过成员初始化表达式生成包含多字段的自定义实例作为分组键

代码实现 #

单字段分组的Lambda表达式构建 #

public static Expression<Func<T, TKey>> CreateSingleFieldGroupKeyLambda<T, TKey>(PropertyInfo keyProperty)
{
    // 定义输入参数表达式（代表原实体）
    var parameter = Expression.Parameter(typeof(T), "x");
    // 构建访问指定属性的表达式
    var propertyAccess = Expression.Property(parameter, keyProperty);
    // 转换为目标类型（需保证属性类型与TKey兼容）
    var convertExpr = Expression.Convert(propertyAccess, typeof(TKey));
    // 生成最终Lambda表达式
    return Expression.Lambda<Func<T, TKey>>(convertExpr, parameter);
}

兼容单/多字段的通用分组键构建 #

如果需要同时支持两种分组场景，可以扩展原方法：

public static LambdaExpression CreateGroupKeyLambda(Type sourceType, List<PropertyInfo> props)
{
    var parameter = Expression.Parameter(sourceType, "x");
    
    if (props.Count == 1)
    {
        // 单字段场景：直接返回属性值作为分组键
        var propertyExpr = Expression.Property(parameter, props[0]);
        return Expression.Lambda(propertyExpr, parameter);
    }
    else
    {
        // 多字段场景：使用原逻辑创建动态类型并生成初始化表达式
        var dynamicType = CreateNewType(props);
        var memberBindings = props.Select(p => Expression.Bind(
            dynamicType.GetField(p.Name), 
            Expression.Property(parameter, p)
        ));
        var memberInitExpr = Expression.MemberInit(
            Expression.New(dynamicType), 
            memberBindings
        );
        return Expression.Lambda(memberInitExpr, parameter);
    }
}

// 保留你原有的动态类型创建方法
public static Type CreateNewType(List<PropertyInfo> props)
{
    AssemblyName asmName = typeof(Program).Assembly.GetName();
    AssemblyBuilder dynamicAssembly = AssemblyBuilder
        .DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Run);
    ModuleBuilder dynamicModule = dynamicAssembly.DefineDynamicModule("MyAsm");
    TypeBuilder dynamicAnonymousType = dynamicModule
        .DefineType("MyType", TypeAttributes.Public);

    foreach (var p in props)
    {
        dynamicAnonymousType.DefineField(p.Name, p.PropertyType, FieldAttributes.Public);
    }
    return dynamicAnonymousType.CreateType();
}

使用示例 #

假设你有User类，要按Id字段分组：

var userType = typeof(User);
var idProperty = userType.GetProperty("Id");
// 生成单字段分组Lambda
var groupKeyLambda = CreateSingleFieldGroupKeyLambda<User, int>(idProperty);
// 应用到GroupBy
var groupedUsers = users.GroupBy(groupKeyLambda.Compile());

这样单字段分组时，GroupBy会直接以原实体的字段值作为分组依据，不会出现自定义类型导致的分组异常；多字段场景则保持原有逻辑正常运行。

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