- c - 在位数组中找到第一个零
- linux - Unix 显示有关匹配两种模式之一的文件的信息
- 正则表达式替换多个文件
- linux - 隐藏来自 xtrace 的命令
我在这个问题上纠结了一个星期,没有找到解决方案。
我有一个如下所示的 POCO:
public class Journal {
public int Id { get; set; }
public string AuthorName { get; set; }
public string Category { get; set; }
public DateTime CreatedAt { get; set; }
}
我想知道在特定日期范围内(按月或年分组)按作者姓名或类别计算的期刊数量。
在我将查询到的对象发送到 JSON 序列化器之后生成如下所示的 JSON 数据(只是使用 JSON 来演示我想要获取的数据,如何将对象序列化为 JSON 不是我的问题)
data: {
'201301': {
'Alex': 10,
'James': 20
},
'201302': {
'Alex': 1,
'Jessica': 9
}
}
或
data: {
'2012': {
'C#': 230
'VB.NET': 120,
'LINQ': 97
},
'2013': {
'C#': 115
'VB.NET': 29,
'LINQ': 36
}
}
我所知道的是以“方法方式”编写 LINQ 查询,例如:
IQueryable<Journal> query = db.GroupBy(x=> new
{
Year = key.CreatedAt.Year,
Month = key.CreatedAt.Month
}, prj => prj.AuthorName)
.Select(data => new {
Key = data.Key.Year * 100 + data.Key.Month, // very ugly code, I know
Details = data.GroupBy(y => y).Select(z => new { z.Key, Count = z.Count() })
});
按月或年、AuthorName或Category分组的条件将通过两个字符串类型的方法参数传递。我不知道的是如何在 GroupBy() 方法中使用“魔术字符串”参数。经过一番谷歌搜索后,似乎我无法通过传递像“AuthorName”这样的神奇字符串来对数据进行分组。我应该做的是构建一个表达式树并将其传递给 GroupBy() 方法。
如有任何解决方案或建议,我们将不胜感激。
最佳答案
哦,这看起来是个有趣的问题:)
所以首先,让我们设置我们的伪源,因为我手头没有你的数据库:
// 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();
所以我们在这里所做的是定义一个自定义的一次性类型,它为我们传入的每个名称都有一个字段,它与源类型上的(Property 或 Field)类型相同。不错!
现在我们如何为 LINQ 提供它想要的东西?
首先,让我们为要返回的函数设置一个“输入”:
// 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),
但是我们到底要为 bindings
使用什么?嗯...好吧,我们想要一些绑定(bind)到源类型中相应属性/字段的东西,但是将它们重新映射到我们的 dynamicType
字段...
var bindings = dynamicType
.GetFields()
.Select(p =>
Expression.Bind(
p,
Expression.PropertyOrField(
sourceItem,
p.Name)))
.OfType<MemberBinding>()
.ToArray();
Oof...看起来很讨厌,但我们还没有完成 - 所以我们需要为我们通过表达式树创建的 Func
声明一个返回类型...当有疑问时,使用对象
!
Expression.Convert( expr, typeof(object))
最后,我们将通过 Lambda
将其绑定(bind)到我们的“输入参数”,使整个堆栈:
// 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)),
bindings),
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()),
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();
// 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)),
bindings),
typeof(object)),
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
}, prj => prj.AuthorName)
.Select(data => new {
Key = data.Key.Year * 100 + data.Key.Month, // very ugly code, I know
Details = data.GroupBy(y => y).Select(z => new { z.Key, Count = z.Count() })
});
var func = db.Epinephelinae(new[]{"CreatedAt", "AuthorName"});
var dquery = db.GroupBy(func, prj => prj.AuthorName);
此解决方案缺乏“嵌套语句”(如“CreatedDate.Month”)的灵 active ,但只要发挥一点想象力,您就可以扩展此想法以处理任何自由形式的查询。
关于c# - 使用表达式树构建 LINQ GroupBy 查询,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/15297884/
给出数据库表中的以下信息: Col 1, Col2, Col3 1 , x , G 1 , y , H 2 , z , J 2 , a , K 2 , a
linq 的一般缺点是什么。 最佳答案 刚开始使用时可能很难理解 延迟执行可以将错误与其原因(在时间方面)分开 进程外 LINQ(例如 LINQ to SQL)总是有点漏洞百出的抽象——你需要知道什么
当我使用 LINQ Where 子句时,返回的项目列表是否遵循它们在原始列表中的顺序? 最佳答案 这取决于被查询的集合如何拥有它的 GetEnumerator被执行。如 GetEnumerator按照
在 Linq 中进行连接时,例如 from c in customers join x in somelistofcustomers on x.Id equals c.Id 你会得到错误 x is n
我正在使用 LINQ 来查询数据。考虑用户只想报告 3 个字段中的 1 个的情况? (见下文) 谁能告诉我如何动态构建查询? 谢谢 DD var query = from cl in db.t
假设我们有下表: Person: PersonID, Name, Age, Gender 并且我们提供了一个搜索功能,允许用户根据名称 来搜索表。和/或 年龄。 编写 SQL(或 LI
这应该很容易。 我要检查两个列表是否相同,因为它们包含所有相同的元素,顺序不重要。 重复的元素被认为是相等的,即new[]{1,2,2}与new[]{2,1}相同 最佳答案 var same = li
假设我有一个数组,我想对varchar进行LINQ查询,该查询返回在varchar中任何位置具有数组元素的任何记录。 这样的事情会很甜蜜。 string[] industries = { "airli
我正在努力寻找 LINQ orderby 示例,其中数据按列索引排序。这是可能的吗? 谢谢 最佳答案 LINQ 中没有列这样的概念,只有字段和属性。您的意思可能是在您创建的匿名类型中指定属性的索引:
我有一个类项目。 class Item{ public int Id { get; set; } public DateTime CreatedDate { get;
我有一张 table 叫做产品。我想获取 productID 为 2 OR 6 OR 9 的所有产品 SQL 是:Select * from products where productID=2 OR
使用时 Contains对于 Linq-to-objects 上的动态 Linq,搜索区分大小写。我希望能够搜索不区分大小写的(如 Linq-to-sql,因为 SQL 服务器默认执行此操作)。 就像
有人能告诉我如何将此查询转换为 linq 吗? SELECT dpr_ts ,dpr_close ,nvl((SELECT pay.pay_dividend
我正在使用linq to实体(EF)。 我有一个采用4个字符串参数的构造函数。根据什么参数不为null,我必须构建linq查询。我可以使用if else语句,但是在这种情况下,我还有其他带有10个参数
下面是我的代码的简化版本。我希望 p1和 p2是平等的,还有p1_after和 p2_after是相等的,因为 GetPerson1() 之间的唯一区别是和 GetPerson2()是 .ToList
关闭。这个问题是opinion-based .它目前不接受答案。 想改善这个问题吗?更新问题,以便可以通过 editing this post 用事实和引文回答问题. 7年前关闭。 Improve t
我看到一些代码是 linq 用于遍历 c# 中的字典对象。我认为 linq 只是用于 linq 到 sql 的数据库。提到的代码中使用的 linq 是一个选择类型的语句,只是没有数据库。 有没有 li
我刚刚开始在一个中型项目中使用LINQ to SQL,并且想加深我对L2S提供的优势的理解。 我看到的一个缺点是它增加了另一层代码,我的理解是,它的性能比使用存储过程和ADO.Net慢。似乎调试也可能
可绑定(bind) LINQ 和连续 LINQ 之间的主要区别是什么? •可绑定(bind)LINQ:www.codeplex.com/bindablelinq • 连续 LINQ:www.codep
Linq 中没有内置全文搜索,而且似乎没有很多关于该主题的帖子,所以我玩了一下,并为我的实用类想出了这个方法: public static IEnumerable GenericFullTextSea
我是一名优秀的程序员,十分优秀!