首先,让我们设置我们的虚假来源,因为我没有你的数据库方便：

// SETUP: fake up a data source
var folks = new[]{"Alex","James","Jessica"};
var cats = new[]{"C#","VB.NET","LINQ"};
var r = new Random();
var entryCount = 100;
var entries = 
    from i in Enumerable.Range(0,entryCount)
    let id = r.Next(0,999999)
    let person = folks[r.Next(0,folks.Length)]
    let category = cats[r.Next(0,cats.Length)]
    let date = DateTime.Now.AddDays(r.Next(0,100) - 50)
    select new Journal() { 
        Id = id,AuthorName = person,Category = category,CreatedAt = date };

好的,现在我们已经有了一组可以使用的数据,让我们看看我们想要什么…我们想要一些像“形状”的东西：

public Expression<Func<Journal,????>> GetThingToGroupByWith(
    string[] someMagicStringNames,????)

它具有与(伪代码)大致相同的功能：

GroupBy(x => new { x.magicStringNames })

让我们一次解剖一件.首先,我们如何动态地做到这一点？

x => new { ... }

编译器通常会为我们带来魔力 – 它的作用是定义一个新的Type,我们也可以这样做：

var sourceType = typeof(Journal);
 
    // define a dynamic type (read: anonymous type) for our needs
    var dynAsm = AppDomain
        .CurrentDomain
        .DefineDynamicAssembly(
            new AssemblyName(Guid.NewGuid().ToString()),AssemblyBuilderAccess.Run);
    var dynMod = dynAsm
         .DefineDynamicModule(Guid.NewGuid().ToString());
    var typeBuilder = dynMod
         .DefineType(Guid.NewGuid().ToString());
    var properties = groupByNames
        .Select(name => sourceType.GetProperty(name))
        .Cast<MemberInfo>();
    var fields = groupByNames
        .Select(name => sourceType.GetField(name))
        .Cast<MemberInfo>();
    var propFields = properties
        .Concat(fields)
        .Where(pf => pf != null);
    foreach (var propField in propFields)
    {        
        typeBuilder.DefineField(
            propField.Name,propField.MemberType == MemberTypes.Field 
                ? (propField as FieldInfo).FieldType 
                : (propField as PropertyInfo).PropertyType,FieldAttributes.Public);
    }
    var dynamicType = typeBuilder.CreateType();

所以我们在这里做的是定义一个自定义的一次性类型,它为我们传入的每个名称都有一个字段,它与源类型上的(属性或字段)类型相同.太好了！

现在我们如何为LINQ提供它想要的东西？

首先,让我们为我们将返回的func设置一个“输入”：

// Create and return an expression that maps T => dynamic type
var sourceItem = Expression.Parameter(sourceType,"item");

我们知道我们需要“新建”我们的新动态类型之一……

Expression.New(dynamicType.GetConstructor(Type.EmptyTypes))

我们需要使用该参数中的值对其进行初始化…

Expression.MemberInit(
    Expression.New(dynamicType.GetConstructor(Type.EmptyTypes)),bindings),

但是我们要用什么来绑定？嗯……好吧,我们想要一些东西绑定到源类型中的相应属性/字段,但是将它们重新映射到我们的dynamicType字段……

var bindings = dynamicType
        .GetFields()
        .Select(p => 
            Expression.Bind(
                 p,Expression.PropertyOrField(
                     sourceItem,p.Name)))
        .OfType<MemberBinding>()
        .ToArray();

Oof ……看起来很讨厌,但我们还没有完成 – 所以我们需要为我们通过Expression树创建的Func声明一个返回类型……如果有疑问,请使用对象！

Expression.Convert( expr,typeof(object))

最后,我们将通过Lambda将它绑定到我们的“输入参数”,从而构成整个堆栈：

// Create and return an expression that maps T => dynamic type
    var sourceItem = Expression.Parameter(sourceType,"item");
    var bindings = dynamicType
        .GetFields()
        .Select(p => Expression.Bind(p,Expression.PropertyOrField(sourceItem,p.Name)))
        .OfType<MemberBinding>()
        .ToArray();
 
    var fetcher = Expression.Lambda<Func<T,object>>(
        Expression.Convert(
            Expression.MemberInit(
                Expression.New(dynamicType.GetConstructor(Type.EmptyTypes)),typeof(object)),sourceItem);

为了便于使用,让我们将整个混乱包装为扩展方法,所以现在我们已经：

public static class Ext
{
    // Science Fact: the "Grouper" (as in the Fish) is classified as:
    //   Perciformes Serranidae Epinephelinae
    public static Expression<Func<T,object>> Epinephelinae<T>(
         this IEnumerable<T> source,string [] groupByNames)
    {
        var sourceType = typeof(T);
    // define a dynamic type (read: anonymous type) for our needs
    var dynAsm = AppDomain
        .CurrentDomain
        .DefineDynamicAssembly(
            new AssemblyName(Guid.NewGuid().ToString()),FieldAttributes.Public);
    }
    var dynamicType = typeBuilder.CreateType();
 
        // Create and return an expression that maps T => dynamic type
        var sourceItem = Expression.Parameter(sourceType,"item");
        var bindings = dynamicType
            .GetFields()
            .Select(p => Expression.Bind(
                    p,p.Name)))
            .OfType<MemberBinding>()
            .ToArray();
 
        var fetcher = Expression.Lambda<Func<T,object>>(
            Expression.Convert(
                Expression.MemberInit(
                    Expression.New(dynamicType.GetConstructor(Type.EmptyTypes)),sourceItem);                
        return fetcher;
    }
}

现在,使用它：

// What you had originally (hand-tooled query)
var db = entries.AsQueryable();
var query = db.GroupBy(x => new 
    {
        Year = x.CreatedAt.Year,Month = x.CreatedAt.Month
    },Count = z.Count() })
    });    
 
var func = db.Epinephelinae(new[]{"CreatedAt","AuthorName"});
var dquery = db.GroupBy(func,prj => prj.AuthorName);

这个解决方案缺乏“嵌套语句”的灵活性,比如“CreatedDate.Month”,但是有了一点想象力,你可以扩展这个想法来处理任何自由形式的查询.