Linq和Lambda的GroupBy方法

最新推荐文章于 2024-05-06 11:22:06 发布
最新推荐文章于 2024-05-06 11:22:06 发布
阅读量692 收藏
点赞数
文章标签： linq 数据库 sql
原文链接：https://blog.csdn.net/WuLex
版权

Group在SQL经常使用，通常是对一个字段或者多个字段分组，求其总和，均值等。

Linq中的Groupby方法也有这种功能。具体实现看代码：

假设有如下的一个数据集：

public class StudentScore
{
public int ID { set; get; }
public string Name { set; get; }
public string Course { set; get; }
public int Score { set; get; }
public string Term { set; get; }
}


List<StudentScore> lst = new List<StudentScore>() 
{
new StudentScore(){ID=1,Name="张三",Term="第一学期",Course="Math",Score=80},
new StudentScore(){ID=1,Name="张三",Term="第一学期",Course="Chinese",Score=90},
new StudentScore(){ID=1,Name="张三",Term="第一学期",Course="English",Score=70},
new StudentScore(){ID=2,Name="李四",Term="第一学期",Course="Math",Score=60},
new StudentScore(){ID=2,Name="李四",Term="第一学期",Course="Chinese",Score=70},
new StudentScore(){ID=2,Name="李四",Term="第一学期",Course="English",Score=30},
new StudentScore(){ID=3,Name="王五",Term="第一学期",Course="Math",Score=100},
new StudentScore(){ID=3,Name="王五",Term="第一学期",Course="Chinese",Score=80},
new StudentScore(){ID=3,Name="王五",Term="第一学期",Course="English",Score=80},
new StudentScore(){ID=4,Name="赵六",Term="第一学期",Course="Math",Score=90},
new StudentScore(){ID=4,Name="赵六",Term="第一学期",Course="Chinese",Score=80},
new StudentScore(){ID=4,Name="赵六",Term="第一学期",Course="English",Score=70},
new StudentScore(){ID=1,Name="张三",Term="第二学期",Course="Math",Score=100},
new StudentScore(){ID=1,Name="张三",Term="第二学期",Course="Chinese",Score=80},
new StudentScore(){ID=1,Name="张三",Term="第二学期",Course="English",Score=70},
new StudentScore(){ID=2,Name="李四",Term="第二学期",Course="Math",Score=90},
new StudentScore(){ID=2,Name="李四",Term="第二学期",Course="Chinese",Score=50},
new StudentScore(){ID=2,Name="李四",Term="第二学期",Course="English",Score=80},
new StudentScore(){ID=3,Name="王五",Term="第二学期",Course="Math",Score=90},
new StudentScore(){ID=3,Name="王五",Term="第二学期",Course="Chinese",Score=70},
new StudentScore(){ID=3,Name="王五",Term="第二学期",Course="English",Score=80},
new StudentScore(){ID=4,Name="赵六",Term="第二学期",Course="Math",Score=70},
new StudentScore(){ID=4,Name="赵六",Term="第二学期",Course="Chinese",Score=60},
new StudentScore(){ID=4,Name="赵六",Term="第二学期",Course="English",Score=70},
};

可以把这个数据集想象成数据库中的一个二维表格。

示例一

通常我们会把分组后得到的数据放到匿名对象中，因为分组后的数据的列不一定和原始二维表格的一致。当然要按照原有数据的格式存放也是可以的，只需select的时候采用相应的类型即可。

第一种写法很简单，只是根据下面分组。

//分组，根据姓名，统计Sum的分数，统计结果放在匿名对象中。两种写法。
//第一种写法
Console.WriteLine("---------第一种写法");
var studentSumScore_1 = (from l in lst
group l by l.Name into grouped
orderby grouped.Sum(m => m.Score)
select new { Name = grouped.Key, Scores = grouped.Sum(m => m.Score) }).ToList();
foreach (var l in studentSumScore_1)
{
Console.WriteLine("{0}:总分{1}", l.Name, l.Scores);
}

第二种写法和第一种其实是等价的。

//第二种写法
Console.WriteLine("---------第二种写法");
var studentSumScore_2 = lst.GroupBy(m => m.Name)
.Select(k => new { Name = k.Key, Scores = k.Sum(l => l.Score) })
.OrderBy(m => m.Scores).ToList();
foreach (var l in studentSumScore_2)
{
Console.WriteLine("{0}:总分{1}", l.Name, l.Scores);
}

示例二

当分组的字段是多个的时候，通常把这多个字段合并成一个匿名对象，然后group by这个匿名对象。

注意：group by后将数据放到grouped这个变量中，grouped 其实是IGrouping<TKey, TElement>类型的，IGrouping<out TKey, out TElement>继承了IEnumerable<TElement>，并且多了一个属性就是Key，这个Key就是当初分组的关键字,即那些值都相同的字段，此处就是该匿名对象。可以在后续的代码中取得这个Key，便于我们编程。

orderby多个字段的时候，在SQL中是用逗号分割多个字段，在Linq中就直接多写几个orderby。

//分组，根据2个条件学期和课程，统计各科均分,统计结果放在匿名对象中。两种写法。
Console.WriteLine("---------第一种写法");
var TermAvgScore_1 = (from l in lst
group l by new { Term = l.Term, Course = l.Course } into grouped
orderby grouped.Average(m => m.Score) ascending
orderby grouped.Key.Term descending
select new { Term = grouped.Key.Term, Course = grouped.Key.Course, Scores = grouped.Average(m => m.Score) }).ToList();
foreach (var l in TermAvgScore_1)
{
Console.WriteLine("学期:{0},课程{1},均分{2}", l.Term, l.Course, l.Scores);
}
Console.WriteLine("---------第二种写法");
var TermAvgScore_2 = lst.GroupBy(m => new { Term = m.Term, Course = m.Course })
.Select(k => new { Term = k.Key.Term, Course = k.Key.Course, Scores = k.Average(m => m.Score) })
.OrderBy(l => l.Scores).OrderByDescending(l => l.Term);
foreach (var l in TermAvgScore_2)
{
Console.WriteLine("学期:{0},课程{1},均分{2}", l.Term, l.Course, l.Scores);
}

示例三

Linq中没有SQL中的Having语句，因此是采用where语句对Group后的结果过滤。

//分组，带有Having的查询，查询均分>80的学生
Console.WriteLine("---------第一种写法");
var AvgScoreGreater80_1 = (from l in lst
							group l by new { Name = l.Name, Term = l.Term } into grouped
							where grouped.Average(m => m.Score)>=80
							orderby grouped.Average(m => m.Score) descending
							select new { Name = grouped.Key.Name, Term = grouped.Key.Term, Scores = grouped.Average(m => m.Score) }).ToList();
foreach (var l in AvgScoreGreater80_1)
{
Console.WriteLine("姓名:{0},学期{1},均分{2}", l.Name, l.Term, l.Scores);
}


Console.WriteLine("---------第二种写法");
//此写法看起来较为复杂，第一个Groupby，由于是要对多个字段分组的，www.it165.net 因此构建一个匿名对象，
//对这个匿名对象分组，分组得到的其实是一个IEnumberable<IGrouping<匿名类型，StudentScore>>这样一个类型。
//Where方法接受，和返回的都同样是IEnumberable<IGrouping<匿名类型，StudentScore>>类型，
//其中Where方法签名Func委托的类型也就成了Func<IGrouping<匿名类型，StudentScore>,bool>,
//之前说到，IGrouping<out TKey, out TElement>继承了IEnumerable<TElement>,
//因此这种类型可以有Average，Sum等方法。

var AvgScoreGreater80_2 = lst.GroupBy(l => new { Name = l.Name, Term = l.Term })
.Where(m => m.Average(x => x.Score) >= 80)
.OrderByDescending(l=>l.Average(x=>x.Score))
.Select(l => new { Name = l.Key.Name, Term = l.Key.Term, Scores = l.Average(m => m.Score) }).ToList();
foreach (var l in AvgScoreGreater80_2)
{
Console.WriteLine("姓名:{0},学期{1},均分{2}", l.Name, l.Term, l.Scores);
}

一些lambda循环操作

 List<GoodsQuestionManageModel> list = JsonConvert.DeserializeObject<GoodsQuestionManageModel[]>(arrayList).ToList();
            //重复前台js所做的判断
            list = list.Where(q => q.QuestionQuantity > 0).ToList();
            list.Where(q => q.GoodsQuestionTypeId == 0).ToList().ForEach(q => strMsg += string.Format("商品Sku为{0}的商品未选择问题类型<br>", q.Sku));
 
//数据判断
IEnumerable<GoodsQuestionManageModel> listSum = list.Where(q => q.IsDelete == 0).GroupBy(q => new { q.Sku, q.GoodsName, q.GoodsQuantity,q.GoodsQuestionTypeId,q.TypeName })
                 .Select(q => new GoodsQuestionManageModel() { GoodsQuestionTypeId=q.Key.GoodsQuestionTypeId,TypeName=q.Key.TypeName,  Sku = q.Key.Sku, GoodsName = q.Key.GoodsName, GoodsQuantity = q.Key.GoodsQuantity, QuestionQuantity = q.Sum(t => t.QuestionQuantity) })
                 .Where(q => q.QuestionQuantity > q.GoodsQuantity);

listSum.ToList().ForEach(q => strMsg += string.Format("商品Sku为{0},问题类型为[{1}]的商品问题数量和{2}大于商品数量{3}<br>", q.Sku,q.TypeName, q.QuestionQuantity, q.GoodsQuantity));

[C#] LINQ之GroupBy

一、先准备要使用的类：

1、Person类：

class Person
{
    public string Name { set; get; }
    public int Age { set; get; }
    public string Gender { set; get; }
    public override string ToString() => Name;
}

2、准备要使用的List，用于分组（GroupBy）：

List<Person> personList = new List<Person>
{
    new Person
    {
        Name = "P1", Age = 18, Gender = "Male"

    },
    new Person
    {
        Name = "P2", Age = 19, Gender = "Male",
    },
    new Person
    {
        Name = "P2", Age = 17,Gender = "Female",
    }
};

二、第一种用法：

public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);

官方释义：根据指定的键选择器函数对序列中的元素进行分组。

我们要分组的集合为source，集合内每个元素的类型为TSource，这里第一个参数keySelector的类型为Func<TSource, TKey>，用于将TSource元素按照由此委托返回的类型TKey进行分组，结果为一个已分好组的集合（集合中的集合）。

编写客户端试验代码如下：

var groups = personList.GroupBy(p => p.Gender);
foreach (var group in groups)
{
    Console.WriteLine(group.Key);
    foreach(var person in group)
    {
        Console.WriteLine($"\t{person.Name},{person.Age}");
    }
}

以上代码指定的KeySelector是Person类的Gender属性，因此，以上会按照Gender（性别）进行分组，我们使用两个嵌套的foreach循环将分组的内容打印到控制台。

因为groups返回的类型为IEnumerable<IGouping<TKey,TSource>>，因此以上返回的类型为IEnumerable<IGouping<string,Person>>。

IGouping<string,Person>是已经分组后的集合，内部集合元素为Person，且IGouping有一个Key属性，类型为string（指的是Gender属性类型），用于分组的标识。

输出结果如下：
在这里插入图片描述
其等价的LINQ语句为：

var groups = from p in personList
             group p by p.Gender;

以上的意思可以这样理解：从personList取出p，并对p进行分组，使用分组的依据（Key）为p.Gender，并将分组的结果存储到pGroup，并将分组的结果选择出来合并成一个集合。

三、第二种用法：

public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);

官方释义：根据指定的键选择器函数对序列中的元素进行分组，并使用指定的比较器对键进行比较。

这种比第一种方法多了一个参数，那就是一个相等比较器，目的是为了当TKey为自定义的类时，GroupBy能根据TKey指定的类根据相等比较器进行分组，

因此，自定义类如何进行分组，GroupBy是不知道的，需要自己定义自己的相等比较器。

首先，将personList更改如下（下划线部分）：

List<Person> personList = new List<Person>
{
    new Person
    {
        Name = "P1", Age = 18, Gender = "Male"

    },
    new Person
    {
        Name = "P1", Age = 19, Gender = "Male",
    },
    new Person
    {
        Name = "P3", Age = 17,Gender = "Female",
    }
};

其次，增加一个相等比较器类，用于对Person进行分组：

class PersonEqualityComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y) => x.Name == y.Name;
    public int GetHashCode(Person obj) => obj.Name.GetHashCode();
}

其中定义了如何对一个Person相等性定义，只要实现IEqualityComparer<Person>即可，这里以Name作为Person类是否相同的依据。

最后，现在我们对Person类进行分组，编写客户端实验代码如下：

var groups = personList.GroupBy(p => p, new PersonEqualityComparer());
foreach (var group in groups)
{
    Console.WriteLine(group.Key.ToString());
    foreach(var person in group)
    {
        Console.WriteLine($"\t{person.Age},{person.Gender}");
    }
}

以上的分组依据是Person类，并运用了自己定义的Person类相同比较器，只要Name相同，就分为一组，

输出结果如下：
在这里插入图片描述

四、第三种用法：

public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector);

官方释义：根据指定的键选择器函数对序列中的元素进行分组，并且通过使用指定的函数对每个组中的元素进行投影。

这个比第一种用法多了一个elementSelector，第一种用法是对集合本身按照TKey分组，并将自己（TSource）添加到分组内，而当前的用法则可以选择自己想要添加到分组内的元素类型。

编写客户端实验代码如下：

var groups = personList.GroupBy(p => p.Gender, p=>p.Name);
foreach (var group in groups)
{
    Console.WriteLine(group.Key.ToString());
    foreach(var name in group)
    {
        Console.WriteLine($"\t{name}");
    }
}

以上代码是按照p.Gender进行分组，并将p.Name作为组内的元素。

输出结果如下：
在这里插入图片描述
其等价的LINQ语句为：

var groups = from p in personList
             group p.Name by p.Gender;

五、第四种用法：

public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector);

官方释义：根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。

这个跟之前的用法都不同，之前的用法都是将结果进行分组，并返回IGrouping<TKey,TSource>对象，而当前用法则是返回自己定义的类型（TResult），在返回自己定义类型之前，将会传入两个参数，一个是TKey，为分组时指定的对象，另外一个则是IEnumerable<TSource>，为分组后的内部对象集合。

编写客户端实验代码如下：

string GetPersonInfo(string gender, IEnumerable<Person> persons)
{
    string result = $"{gender}:\t";
    foreach (var p in persons)
    {
        result += $"{p.Name},{p.Age}\t";
    }
    return result;
}
var results = personList.GroupBy(p => p.Gender,(g, ps) => GetPersonInfo(g,ps));
foreach (var result in results)
{
    Console.WriteLine(result);
}

GetPersonInfo为局部方法，见于C#7.0及以上。

以上代码将分组后的内容（一个是TKey，为p.Gender，另外一个是IEnumerable<TSource>，为IEnumerable<Person>）作为字符串输出，因此，将返回的类型为字符串集合。

输出结果如下：
在这里插入图片描述
其等价的LINQ语句为：

var results = from p in personList
              group p by p.Gender into pGroup
              select GetPersonInfo(pGroup.Key, pGroup);

六、第五种用法：

public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer);

官方释义：根据键选择器函数对序列中的元素进行分组。通过使用比较器对键进行比较，并且通过使用指定的函数对每个组的元素进行投影。

与第三种用法基本相同，只是多了一个相等比较器，用于分组的依据。

使用第二种用法的personList及PersonEqualityComparer，编写客户端实验代码如下：

var groups = personList.GroupBy(p => p, p => new { p.Age,p.Gender },new PersonEqualityComparer());
foreach (var group in groups)
{
    Console.WriteLine(group.Key.ToString());
    foreach (var name in group)
    {
        Console.WriteLine($"\t{name.Age},{name.Gender}");
    }
}

以上代码的分组依据是Person，PersonEqualityComparer则是作为Person分组的比较器，每个组内为一个匿名类型集合。

输出结果如下：
在这里插入图片描述

七、第六种用法：

public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey> comparer);

官方释义：根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。通过使用指定的比较器对键进行比较。

与第四种用法基本相同，只是多了一个相等比较器，用于分组的依据。

使用第二种用法的personList及PersonEqualityComparer，编写客户端实验代码如下：

string GetPersonInfo(Person person, IEnumerable<Person> persons)
{
    string result = $"{person.ToString()}:\t";
    foreach (var p in persons)
    {
        result += $"{p.Age},{p.Gender}\t";
    }
    return result;
}
var results = personList.GroupBy(p => p, (p, ps) => GetPersonInfo(p, ps),new PersonEqualityComparer());
foreach (var result in results)
{
    Console.WriteLine(result);
}

以上代码的分组依据是Person，PersonEqualityComparer则是作为Person分组的比较器，每个组内为一个Person集合，并将返回类型为string的字符串输出。

输出结果如下：
在这里插入图片描述

八、第七种用法：

public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector);

官方释义：根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。通过使用指定的函数对每个组的元素进行投影。

与第四种方法很类似，只是对分组内的元素进行选择，原有为TSource，现改为TElement。

编写客户端实验代码如下：

string GetPersonInfo(string gender, IEnumerable<string> names)
{
    string result = $"{gender}:\t";
    foreach (var name in names)
    {
        result += $"{name}\t";
    }
    return result;
}
var results = personList.GroupBy(p => p.Gender, (p=>p.Name) ,(g, ns) => GetPersonInfo(g, ns));
foreach (var result in results)
{
    Console.WriteLine(result);
}

以上代码将使用Gender分组，并将分组后的信息组合成一条字符串，并输出到控制台。

输出结果如下：
在这里插入图片描述

九、第八种用法：

public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey> comparer);

官方释义： 根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。通过使用指定的比较器对键值进行比较，并且通过使用指定的函数对每个组的元素进行投影。

与第七种用法基本相同，只是多了一个相等比较器，用于分组的依据。

使用第二种用法的personList及PersonEqualityComparer，编写客户端实验代码如下：

var results = personList.GroupBy(p => p, (p=>new { p.Age,p.Gender}),
    (p, ns) => 
    {
        string result = $"{p.ToString()}:\t";
        foreach (var n in ns)
        {
            result += $"{n.Age},{p.Gender}\t";
        }
        return result;
    },new PersonEqualityComparer());
foreach (var result in results)
{
    Console.WriteLine(result);
}

以上代码将使用Person分组，使用Person比较器作为分组的依据，并将分组后的信息组合成一条字符串，并输出到控制台。

输出结果如下：
在这里插入图片描述

.NET跨平台
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Lambda中groupBy分组用法
zk_chs的博客
03-12 3万+
这次的博客给大家带来点lambda中groupBy分组语法的使用   首先我们新建一个对象，通过这个对象的集合来进行学习： @Data @Builder public class Person (){ private int grade; private boolean isBoy; }  很简单的一个类，grade表示年级，isBoy表示性别，男为t...
Linq 和 Lambda 查询中按照多个值进行分组GroupBy
Denghejing的专栏
06-07 1万+
创建要查询的对象： class Employee { public int ID { get;set; } public string FName { get; set; } public int Age { get; set; } public char Sex { get; set; } }如果对这个类的Age和Sex的连个字段进行分组，方法如下：// 先造一些数据 L
Lambda(Linq)表达式GroupBy()的两种用法
有趣技术
02-20 7018
前言 GroupBy通常用于分组统计，可根据单字段或某些字段区进行合并统计数据 Lambda的思想与SQL语句类型，如以下例子： 统计和B、C、D同组的数量 用法1 List<Order> Orders= samples.GroupBy(p => new { p.B, p.C, p.D}) //D,B,C是samples的属性 .Select(p => new Order {
Java8 Labmbda 表达式
最新发布
sinat_34814635的博客
05-06 361
groupby方法有几个重载方法，上面使用的方法有三个参数第一个参数表示分组按照什么进行分类第二个参数表示分组结果最后用什么容器保存并返回，可以指定为LinkedHashMap，HashMap等第三个参数表示分类后，对应的分类的结果如何收集踩坑分享。
LambdaQueryWrapper使用 group分组、sum聚合函数 进行统计，并分页排序
热门推荐
小楊同学的笔记本
09-16 4万+
首先，我们要知道，其实LambdaQueryWrapper是无法使用sum聚合函数的，因为LambdaQueryWrapper的select()方法无法传入字符串，但你有张良计,我有过墙梯，我们其实可以迂回来做。
LambdaQueryWrapper 查询拼接SQL语句、Group by 分组用法
mchgogo的博客
08-30 1万+
2、拼接SQL语句用法 如 Wrappers.query().lambda().. 后加last 拼接SQL。至于基础的eq、like、one、or 、list、last 等用法就不在这里说了。主要是帮我们动态的拼接SQL查询条件。4、Lambda 表达式两种方式来演示。3、 Wrapper 条件构造器中。5、Lambda形式。
mybatis-plus条件构造器LambdaQueryWrapper方法详细
xsxbc的博客
01-28 2796
where: WHERE 语句，拼接 + WHERE 条件 and: AND 语句，拼接 + AND 字段=值 andNew: AND 语句，拼接 + AND (字段=值) or: OR 语句，拼接 + OR 字段=值 orNew: OR 语句，拼接 + OR (字段=值) eq: 等于= allEq: 基于 map 内容等于= ne: 不等于<> gt: 大于> ge: 大于等于>= lt: 小于< le: 小于等于<= like: 模糊查询 LIKE notLike:
Linq语句和Lambda表达式
weixin_44569910的博客
04-26 368
LINQ即语言集成查询，是.NET Framework 3.5中新增的功能。其功能类似于数据库中的SQL语句(实际上LINQ就是针对.NET Framework的SQL)：提供标准的、易于学习的查询和更新数据模式。 从from开始： 用过SQL的朋友都知道，最简单的SQL语句SELECT record FROM tableName：获取表中的所有记录，那么对应于LINQ，其语法如下： from r...
C#高级编程_Lambda表达式和LINQ的原理和使用
07-09
LINQ的核心在于它的查询运营商，如`Select()`, `Where()`, `GroupBy()`等。下面是一个简单的LINQ查询示例，用于筛选列表中年龄大于20的人： ```csharp var adults = people.Where(p => p.Age > 20); ``` 在这个...
C# Linq lambda表达式.doc
11-06
虽然示例中没有直接展示分组操作，但`GroupBy()`方法可以用于将数据按照特定键进行分组。例如： ```csharp var groups = collection.GroupBy(c => c.Property).ToList(); ``` 这将按照`Property`字段对`...
Linq Grouping GroupBy 用法详解
12-31
`GroupBy`方法可以与其他LINQ操作，如`OrderBy`和`Where`结合使用，实现更复杂的查询： ```csharp var topStudents = students .GroupBy(s => s.Class) .OrderByDescending(g => g.Average(s => s.Grade)) .Take...
Linq_Lambda_Expressions：Curso de Linq Lambda表达式
02-14
1. **查询语法与方法语法**：LINQ提供两种查询形式，即查询语法（Query Syntax）和方法语法（Method Syntax）。查询语法更接近SQL，而方法语法则基于一系列扩展方法如`Where()`, `Select()`, `GroupBy()`等。 2. **...
C# 中的GroupBy的动态拼接问题及GroupBy<>用法介绍
08-28
在C# 中，GroupBy方法是 LINQ（Language Integrated Query）的一部分，用于将集合中的元素分组到不同的组中。GroupBy方法的基本语法是：`collection.GroupBy(keySelector)`,其中`keySelector`是一个 lambda 表达式，...
Lambda表达式GroupBy多条件分组
u011511086的专栏
12-22 8888
lambda表达式GroupBy多列分组
lambda GroupBy
zq爱生活爱代码的博客
03-01 957
标准用法 public class Student { public string Name { get; set; } public bool Graduation { get; set; } public int Age { get; set; } public int Score { get; set; } public string Ci...
LambdaQueryWrapper的使用
qq_37834811的博客
03-01 8845
"揭秘高效编程：如何用LambdaQueryWrapper让数据库查询简单又强大？"
lambdaQueryWrapper常用方法
m0_67265464的博客
07-28 1万+
apply(“date_format(dateColumn,‘%Y-%m-%d’)={0}”,“2022-02-08”)------>date_format(dateColum,‘%Y-%m-%d’)=‘2022-02-08’and(i->i.eq(“name”,“张三”).ne(“age”,20)------>and(name=‘张三’andage20)notLike(“name”,“张三”)------>namenotlike‘%张三%’...
Lamda表达式
weixin_42138135的博客
04-14 498
List<User> userList = new ArrayList<>(); ListToMap Map<Long, User> maps = userList.stream().collect(Collectors.toMap(User::getId, Function.identity(), (key1, key2) -> key2)); map转list map.entrySet().stream().map(e -> new Person(e.
.Net Linq与Lambda表达式中GroupBy以多个字段分组
06-03
在 .Net Linq与Lambda表达式中，可以使用匿名对象来实现多个字段的分组。具体的实现方法如下： 假设有一个类Person，包含属性Name、Age、City，现在需要按照Name和City字段进行分组，代码如下： ```csharp List<Person> personList = new List<Person>(); var groupedList = personList.GroupBy(p => new { p.Name, p.City }); ``` 在这里，我们使用了一个匿名对象，包含了两个属性Name和City，这样就可以按照这两个属性进行分组了。如果需要加入更多的分组条件，只需要在匿名对象中添加对应的属性即可。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值