基于Group by动态聚合：通过字段名动态替换Lambda表达式属性

Hey there! Let's figure out how to swap out that hardcoded x.BaseSalary with your dynamic fieldtoretrive variable, so you can calculate averages for any specified Employee property. I'll walk you through a couple of solid approaches depending on your ORM setup.

方法1：用EF Core的EF.Property（推荐，简单直接） #

If you're working with EF Core, the EF.Property method is your best friend here—it lets you access a property by name, and EF Core can parse it into proper SQL (so you don't end up pulling all data into memory first). Assuming your target property is a numeric type like decimal, here's how to adjust your code:

var fieldtoretrive = "BaseSalary";
var groupcal = db.Employees
    .GroupBy(x => x.Region)
    .Select(group => new 
    { 
        Key = group.Key, 
        Avg = group.Average(x => EF.Property<decimal>(x, fieldtoretrive)) 
    })
    .ToList();

If you need to support multiple numeric types (like int or double) and don't want to hardcode the type, you can use dynamic (just note that some older EF Core versions might have minor parsing quirks with this):

Avg = group.Average(x => (dynamic)EF.Property(x, fieldtoretrive))

方法2：手动构建表达式树（灵活适配更多场景） #

If you're using EF6 or need more control over type conversions, building an expression tree manually works great. This lets you safely access the property and handle type conversions if needed.

First, create a helper method to generate the property-access lambda:

private static Expression<Func<T, decimal>> GetPropertyAccessor<T>(string propertyName)
{
    var param = Expression.Parameter(typeof(T), "x");
    var property = Expression.Property(param, propertyName);
    // Add a conversion to decimal if your property is a different numeric type (like int)
    var convertExpr = Expression.Convert(property, typeof(decimal));
    return Expression.Lambda<Func<T, decimal>>(convertExpr, param);
}

Then use it in your query:

var fieldtoretrive = "BaseSalary";
var propertyLambda = GetPropertyAccessor<Employee>(fieldtoretrive);
var groupcal = db.Employees
    .GroupBy(x => x.Region)
    .Select(group => new 
    { 
        Key = group.Key, 
        Avg = group.Average(propertyLambda) 
    })
    .ToList();

内存集合的反射方法（仅适用于本地数据） #

If you're working with an in-memory list (not an EF query), you could use reflection—but keep in mind it's slower than the expression tree approach for large datasets:

var propertyInfo = typeof(Employee).GetProperty(fieldtoretrive);
var groupcal = employeesList
    .GroupBy(x => x.Region)
    .Select(group => new 
    { 
        Key = group.Key, 
        Avg = group.Average(x => (decimal)propertyInfo.GetValue(x)) 
    })
    .ToList();

Quick Notes #

• Double-check that fieldtoretrive matches an existing numeric property on your Employee class—otherwise you'll get a runtime error.
• Stick with method 1 if you're on EF Core; it's the cleanest and most efficient option.

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