C#高级：利用Lambda表达式和数据库SQL进行分组、去重处理

已于 2024-07-26 20:52:02 修改
阅读量1.3k 收藏 2
点赞数 1
分类专栏： C#高级 文章标签： c# 开发语言 数据库
于 2023-11-08 15:55:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67412019/article/details/134291698
版权

第一部分内容可以直接在控制台程序输出

目录

一、基础分组处理

二、含列表分组处理

三、多组别分组处理（复杂，一般很少用）

四、基础去重处理

（1）程序写法

（2）SQL写法

五、一些小结

1.初始化区别

2.列表初始化注意的点

3.如何将Object转为实体

一、基础分组处理

class MainClass
{
    static List<Student> StudentList = new List<Student>()
    {
        new Student(){ Id=1,Name="小明",Classes="201班",Sex="男",Score=90},
        new Student(){ Id=2,Name="小虹",Classes="201班",Sex="女",Score=99},
        new Student(){ Id=3,Name="小二",Classes="202班",Sex="男",Score=60},
        new Student(){ Id=4,Name="小宫",Classes="202班",Sex="男",Score=50},
        new Student(){ Id=5,Name="小蓝",Classes="202班",Sex="女",Score=60},
        new Student(){ Id=6,Name="小力",Classes="202班",Sex="男",Score=70},
        new Student(){ Id=7,Name="小梅",Classes="202班",Sex="女",Score=90},
        new Student(){ Id=8,Name="小萱",Classes="203班",Sex="女",Score=20}
    };
    static void Main(string[] args)
    {
        //1.查询有多少个不一样的班级（去重）
        List<string> list1 = StudentList.Select(x => x.Classes).Distinct().ToList();
        //List<string> list2 = StudentList.Select(x => x.Classes).ToHashSet().ToList();//也可以这样写

        //【分组结构分析（以2为例）】：201班、202班、203班分别有一个列表，s是分组依据、g是组长列表，x是组员实体
        IEnumerable<IGrouping<string, Student>> temp = StudentList.GroupBy(s => s.Classes);//temp=三个列表

        // 2.每个班为一组，统计出每个班的总分
        var list2 = StudentList.GroupBy(s => s.Classes).Select(g => new { Class = g.Key, TotalScore = g.Sum(x => x.Score) }).ToList();
        Console.WriteLine(string.Join("\n", list2));

        // 3.每个班、每个性别为一组，统计出每个班、每个性别的总分
        var list3 = StudentList.GroupBy(s => new { s.Classes, s.Sex }).Select(g => new { Class = g.Key.Classes, Gender = g.Key.Sex, TotalScore = g.Sum(x => x.Score) }).ToList();
        Console.WriteLine(string.Join("\n", list3));

        //4.每个班、每个性别为一组，统计出每个班、每个性别的Score小于60的数量以及它们的姓名、代表姓名、该班该性别下学生的所有姓名
        var list4 = StudentList.GroupBy(s => new { s.Classes, s.Sex })
                                     .Select(g => new
                                     {
                                         Class = g.Key.Classes,
                                         Gender = g.Key.Sex,
                                         Count = g.Count(x => x.Score < 60),//该班该性别不及格的数量
                                         Names = string.Join(", ", g.Where(x => x.Score < 60).Select(x => x.Name)),//该班该性别不及格的姓名
                                         Names2 = g.FirstOrDefault()?.Name,//学生代表，列表第一位
                                         Names3 = g.Select(x=>x.Name)//该班该性别下学生的所有姓名（返回的是list）
                                     });
        Console.WriteLine(string.Join("\n", list4));
    }
}
class Student
{
    public int Id;
    public string Name;
    public string Classes;
    public string Sex;
    public int Score;
}

二、含列表分组处理

【数据库查表数据】ProjectID,Price,Stamonths=[time,Money]

项目名项目金额1月成本2月成本
项目1200100200
项目11005060
项目210003080
项目230010040
项目315008060

分组前——list

项目1 项目金额 [月份1金额 月份2金额](List<Stamonths>)

项目1 项目金额 [月份1金额 月份2金额]

项目2 项目金额 [月份1金额 月份2金额]

项目2 项目金额 [月份1金额 月份2金额]

项目3 项目金额 [月份1金额 月份2金额]

【前端展现页面】

项目名项目金额1月成本2月成本
项目1300150260
项目1200100200
项目11005060
项目21300130120
项目210003080
项目230010040
项目315008060
项目315008060

【说明】

1.粉色是父节点，其他为子节点

2.代码中g是加粗部分，s是非加粗部分

分组后——result_list（缩进代表是Children下的数据）

项目1 项目总金额 [月份1总金额 月份总2金额](List<Stamonths>)

        项目1 项目金额 [月份1金额 月份2金额]

        项目1 项目金额 [月份1金额 月份2金额]

项目2 项目总金额 [月份1总金额 月份总2金额]

        项目2 项目金额 [月份1金额 月份2金额]

        项目2 项目金额 [月份1金额 月份2金额]

项目3 项目总金额 [月份1总金额 月份总2金额]

        项目3 项目金额 [月份1金额 月份2金额]

代码： 

var result_list = list.GroupBy(s => new { s.ProjectID })
                        .Select(g => new
                        {
                            ProjectID = g.Key.ProjectID,//组别，即项目ID
                            TotalPrice = g.Sum(s => s.Price),//汇总数据：处理项目总金额，实现对Children的各项目金额相加
                            Stamonths = g.SelectMany(s => s.Stamonths)//汇总数据：拿出列表分组=》实现对Children的列表金额相加
                                          .GroupBy(s => s.Time)
                                          .Select(s => new
                                          {
                                              time = s.Key,
                                              Money = s.Sum(x => x.Money)
                                          })
                                          .ToList(),
                            Children=g.Select(s => new//列出子数据
                                  {
                                      s.ProjectID,
                                      s.Price,
                                      Stamonths = s.Stamonths
                                  })
                        })
                        .ToList();

三、多组别分组处理（复杂，一般很少用）

【数据库查表数据】

小组(负责人)产品名称产品经理产品批次产品成本售出批次销售价格销售日期
医疗组(xiaoxiao)专专产品新测试员2023产品批次1200默认批次100002022/1/1
医疗组(xiaoxiao)专专产品新测试员2023产品批次2100默认批次100002022/1/1
医疗组(xiaoxiao)专专产品新测试员2023产品批次1200批次230002022/1/2
医疗组(xiaoxiao)专专产品新测试员2023产品批次2100批次230002022/1/2
医疗组(xiaoxiao)专专产品新测试员2023产品批次1200批次31500NULL
医疗组(xiaoxiao)专专产品新测试员2023产品批次2100批次31500NULL

【前端展现页面】

小组(负责人)产品名称产品经理产品批次产品成本销售总收入售出批次销售价格销售日期
医疗组(xiaoxiao)专专产品新测试员2023产品批次120014500默认批次100002022/1/1
批次230002022/1/2
产品批次2100批次31500NULL

小组：产品：产品经理=1：1：1； 产品：产品批次=1：n ； 产品：售出批次=1：n ；产品批次和售出批次无直接对应关系；颜色说明了它们之间的对应关系。 

【期望返回数据格式】

[
  {
    "GroupName": "医疗组",
    "Leader": "xiaoxiao",
    "productName": "专专产品",
    "productManager": "新测试员2023",
    "productSumIncome": 300,
    "productDetails": [
        {
            "productBatchesName": "产品批次1",
            "projectCost": 200
        },
        {
            "productBatchesName": "产品批次2",
            "projectCost": 100
        }
    ],
    "salesDetails": [
        {
            "salesBatchsName": "批次3",
            "settleTime": null,
            "salesPrice": 1500
        },
        {
            "salesBatchsName": "默认批次",
            "settleTime": null,
            "salesPrice": 10000
        },
        {
            "salesBatchsName": "批次2",
            "settleTime": null,
            "salesPrice": 3000
        }
    ]
}
]

【代码编写策略】先分组，后筛选

 var resultlist = product_list.GroupBy(d => new
                 {//不同组名、不同负责人、不同产品、不同产品经理为一组
                     d.GroupName,
                     d.LeaderName,
                     d.ProductName,
                     d.ProjectManager
                 })
                 .Select(g => new
                 {//筛选出我要的内容
                     Name = g.Key.GroupName,//组别
                     Leader = g.Key.LeaderName,
                     ProductName = g.Key.ProductName,
                     ProductManager = g.Key.ProjectManager,
                     ProductSumIncome = g.GroupBy(x => x.SalesBatchsName).Sum(x=>x.FirstOrDefault()?.ProductIncome),//小组信息汇总，即【Flag】处加和，代表销售总收入
                     ProductDetails = g.GroupBy(x => x.ProBatchesName).Select(//小组信息展示（产品分组，对应蓝色框框）
                         s => new
                         {
                             ProductBatchesName = s.Key,//组别，即ProBatchesName（产品批次名）
                             ProjectCost = s.FirstOrDefault()?.ProjectCost//小组成员对应的信息
                         }),
                     SalesDetails = g.GroupBy(x => x.SalesBatchsName).Select(s => new//小组信息展示（销售分组，对应粉色框框）
                     {
                         SalesBatchsName = s.Key,//组别，即BatchesName（销售批次名）
                         SettleTime = s.FirstOrDefault()?.SettleTime,
                         SalesPrice = s.FirstOrDefault()?.ProductIncome//【Flag】
                     })
                 }) ;

四、基础去重处理

（1）程序写法

class MainClass
{
    static List<Product> ProductList = new List<Product>()
    {
        new Product(){ Id=1,Name="产品1号",CustormuerName="李老板",Batches="批次1"},
        new Product(){ Id=1,Name="产品1号",CustormuerName="王老板",Batches="批次1"},
        new Product(){ Id=1,Name="产品1号",CustormuerName="王老板",Batches="批次1"},
        new Product(){ Id=1,Name="产品1号",CustormuerName="李老板",Batches="批次2"},
        new Product(){ Id=2,Name="产品2号",CustormuerName="苏老板",Batches="批次1"},
        new Product(){ Id=2,Name="产品2号",CustormuerName="李老板",Batches="批次1"}
    };
    static void Main(string[] args)
    {

        //(1)数据一样的去重
        var list1_1 =  ProductList
                        .GroupBy(p => new { p.Id, p.Name, p.CustormuerName, p.Batches })
                        .Select(g => g.First())
                        .ToList();

        //(2)产品名字一样的去重,返回第一条
        var list1_2 = ProductList.DistinctBy(x => x.Name).ToList();

        //(3)产品名字和客户名字一样的去重,返回第一条
        var list1_3 = ProductList.DistinctBy(x => new 
            { 
                x.Name, x.CustormuerName 
            }).ToList();
    }
}
class Product
{
    public int Id;
    public string Name;
    public string CustormuerName;
    public string Batches;
}

（2）SQL写法

--(1)内容一样去重，返回第一条
SELECT Name, CustormuerName, Batches, Income
FROM ProductTable
GROUP BY Name, CustormuerName, Batches, Income

--(2)产品名字一样的去重,返回第一条
SELECT Name
FROM ProductTable
GROUP BY Name

--(3)产品名字和客户名字一样的去重,返回第一条
SELECT Name, CustormuerName
FROM ProductTable
GROUP BY Name, CustormuerName

【SQL分组注意】
1.GROUP BY 字段要和SELECT字段一致
2.聚合函数使用：MAX可以取分组后的第一个代表元素，COUNT(*)可以表示分组之后该小组有多少条数据，AVG,SUM等函数是计算小组某个字段的平均值和总和的。
3.如果想取小组中的指定序号的成员，需要用ROW_NUMBER()关键字处理。 

五、一些小结

1.初始化区别

  • new List<object>(resultlist)：将 resultlist 中的元素逐个复制到新的列表中。
  • new List<object>{resultlist}：将 resultlist 作为单个元素添加到新的列表中。
  • 第一种结构就是List<object>，即 ["item1", "item2", "item3"]
  • 第二种结构是List<object>下带有resullist，即 [{"resultlist": ["item1", "item2", "item3"]}]

2.列表初始化注意的点

  • 需要写两个new
//【字段】
public class ProjectIncomeResult
{
     public decimal TotalPriceSum { get; set; }
     public List<MonthlyIncomSums> MonthlyIncomeSumList { get; set; }
}
//【写法】
var resultlist = new List<ProjectIncomeResult> { 
          new ProjectIncomeResult
          {
               TotalPriceSum=10000,
               MonthlyIncomeSumList = monthlyIncomeSums 
          }
};

  • 封装的写法(result是已写好的结构)

var resultlist = new List<ProductResult> (result)

3.如何将Object转为实体

【步骤】：

     第一步，照着object类写实体字段。（也可以叫AI写）

     第二步，在object类的【Select】里面的【new】后面加上具体的实体类

     第三步，在object类的屁股后加【.ToList()】

【原来的object类】

var resultlist = product_list.GroupBy(d => new
               {
                    d.AmoebaName,
                    d.AmoebaLeaderName,
               })
               .Select(g => new 
               {
                    AmoebaName = g.Key.AmoebaName,
                    AmoebaLeader = g.Key.AmoebaLeaderName,
                    ProductSumCost = g.GroupBy(x=>x.ProBatchesName).Sum(x=>x.FirstOrDefault()?.ProjectCost),
                    ProductSumIncome = g.GroupBy(x => x.BatchsName).Sum(x=>x.FirstOrDefault()?.ProductIncome),
                    SalesDetails = g.GroupBy(x => x.BatchsName).Select(s => new 
                    {
                         SalesBatchsName = s.Key,
                         SettleTime = s.FirstOrDefault()?.SettleTime,
                         SalesPrice = s.FirstOrDefault()?.ProductIncome
                    })
               });

【第一步，写字段】

public class ProductResult
{
     public string AmoebaName { get; set; }
     public string AmoebaLeader { get; set; }
     public double? ProductSumCost { get; set; }
     public double? ProductSumIncome { get; set; }
     public IEnumerable<SalesDetail> SalesDetails { get; set; }//实体下面有集合
}
public class SalesDetail
{
     public string SalesBatchsName { get; set; }
     public DateTime? SettleTime { get; set; }
     public double? SalesPrice { get; set; }
}

【第二三步，加具体实体和加Tolist()】

var resultlist = product_list.GroupBy(d => new
               {
                    d.AmoebaName,
                    d.AmoebaLeaderName,
               })
               .Select(g => new ProductResult
               {
                    AmoebaName = g.Key.AmoebaName,
                    AmoebaLeader = g.Key.AmoebaLeaderName,
                    ProductSumCost = g.GroupBy(x=>x.ProBatchesName).Sum(x=>x.FirstOrDefault()?.ProjectCost),
                    ProductSumIncome = g.GroupBy(x => x.BatchsName).Sum(x=>x.FirstOrDefault()?.ProductIncome),
                    SalesDetails = g.GroupBy(x => x.BatchsName).Select(s => new SalesDetail
                    {
                         SalesBatchsName = s.Key,
                         SettleTime = s.FirstOrDefault()?.SettleTime,
                         SalesPrice = s.FirstOrDefault()?.ProductIncome
                    })
               }).ToList() ;

【注意】实体类需用等于号赋值，不能省略

result.ReturnData = new ManPowAllResult 
                    {
                        resultlist=resultlist,
                        allSumlist=allSumlist
};

我是苏苏
关注
专栏目录
lambda表达式分组,过滤,求和,最值,排序,去重
jamesluozhiwei的博客
08-07 4830
文章目录简介实例先准备个实体类分组过滤求和最值List转Map排序去重获取list对象某个字段组装新的list批量设置list列表字段为同一个值 简介 Java 8 新特性 java8的lambda表达式提供了一些方便list操作的方法，主要涵盖分组、过滤、求和、最值、排序、去重。跟之前的传统写法对比，能少写不少代码。 实例 先准备个实体类 import java.math.BigDecima...
C#将Lambda表达式转成Sql语句
09-21
总的来说，将C#的Lambda表达式转换为SQL语句是一项复杂但非常实用的任务，它使我们能够在不离开C#环境的情况下编写复杂的数据库查询，同时保持代码的清晰和简洁。这种技术对于开发高效、灵活的ORM（对象关系映射）...
C#中Lambda表达式总结
weixin_43628744的博客
11-19 1099
在C#的语法中有一种比较特殊的写法，叫做Lambda表达式，这种表达式的写法在于你查询数据的时候直接是使用以下箭头的形式来表示查询语句的：=>。例如，我们要查找学生的List<Student>集合中班级编号为1001的所有学生数据，我们即可用Studentlist.Where(t=>t.ClassCode=‘1001’)语句来直接完成，无需再写繁琐的foreach语句或者for循环。Lambda表达式的运算符即为=>。 一、Lambda表达式定义 Lambda表...
使用Lambda表达式进行分组
alai_5186_cdsn的专栏
08-31 576
【代码】使用Lambda表达式进行分组。
C# Lambda表达式
bikeRiver
02-02 241
委托如下： delegate int calculator(int x, int y); //委托类型 static void Main() { calculator cal = new calculator(Adding); int He = cal(1, 1); Console.Wri
Lambda 表达式（C# 编程指南）
wyh0318的专栏
03-07 480
“Lambda 表达式”是一个匿名函数，它可以包含表达式和语句，并且可用于创建委托或表达式树类型。 所有 Lambda 表达式都使用 Lambda 运算符 =>，该运算符读为“goes to”。 该 Lambda 运算符的左边是输入参数（如果有），右边包含表达式或语句块。 Lambda 表达式 x => x * x 读作“x goes to x times x”。可以将此表达式分配给委托类型
C#高级编程_Lambda表达式和LINQ的原理和使用
07-09
在C#编程中，Lambda表达式和LINQ是两种强大的工具，它们极大地简化了代码的编写，特别是处理数据查询和事件处理。理解这两者的工作原理和使用方式是成为C#高级程序员的关键步骤。 Lambda表达式是匿名函数的一种简洁...
C#连接数据库 —— （二）Linq To EF 的 lambda表达式使用 ，增删查改、判断、分组、排序
12-14
在C#中，Linq to Entity Framework (Linq To EF) 是一种强大的工具，用于处理数据库操作，如增删查改、数据判断、分组和排序。Lambda表达式是实现这些操作的关键，它使得代码更加简洁和易于理解。在本篇文章中，我们...
基于C#语言的Lambda表达式转SQL小型ORM框架设计源码
最新发布
10-01
本项目是一款基于C#语言的Lambda表达式转换器，旨在构建一个小型ORM（对象关系映射）框架。源码包含106个文件，其中包括67个C#源代码文件、10个DLL库文件、10个缓存文件、4个XML配置文件、3个配置文件、3个PDB调试...
基于Lambda表达式的SQL语句生成器SqlLink V0.1
03-25
SqlLink V0.1是一款基于Lambda表达式的SQL语句生成器，主要针对C#开发者设计，旨在简化.NET框架下的数据库操作。Lambda表达式是.NET框架3.5及以上版本引入的一种强大的编程工具，它使得代码更加简洁、易读，尤其是在...
非常全面的lambda表达式对List集合去重、分组、排序、过滤、求和、最值方法工具类
热门推荐
严老板的技术梦想博客
06-05 4万+
我们经常会对list集合去重，于是我自己花了点时间将如何用 lambda表达式对list集合去重做了封装和测试，方便以后快速使用。包括对对象集合中的某个属性去重等。如果有特殊的list去重要求，可以自行对下列方法进行修改。 下列方法是本人验证过比较简便的写法，请参考： import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.function.Function; import java.util.f
lambda表达式分组、过滤、排序、转map、求和、求最值
陆总的博客
10-30 2055
在jdk1.8中lambda表达式提供了集合的一些很实用的操作方法，函数式编程既减少了很多繁杂的foreach代码，又简洁明了，通俗易懂。 @Data public class User { private String userId; private String username; private String nickName; private String password; private String picPath;
c# list＜T＞ lambda表达式 取某一属性并去重
尽力而行
10-14 4308
方法一 lambda+ Distinct() //方法一： //.Select(t => t.posType)-- 查询列表里所有的posType属性 //.Distinct()--值类型List去重 //.ToList()--转换为 List<int> 类型 List<int> listPosType = magList.Select(t => t.posType).Distinct().ToList(); 方法.
lambda 表达式，对数据的分组
qq_39822451的博客
03-28 1万+
//单条件分组， Map<String, List<YourBean>> mapByOne = yourBeanList.stream().collect(Collectors.groupingBy(YourBean::getBillDateStr)); //分组后，统计每组中数据量 Map<String, Long...
lambda表达式去重
qq_40332663的博客
10-27 2671
字符串去重 List<String> dataList = list.stream().distinct().collect(Collectors.toList()); 对象属性去重 //根据getName去重 personList = personList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection( () -> new TreeSet..
Lambda表达式去重
lj_heaven的博客
12-05 904
【代码】Lambda表达式去重。
lambda表达式去除重复数据
01-29 1万+
Enumerable.DistinctTSource> 方法 (IEnumerableTSource>) Listint> ages = new Listint> { 21, 46, 46, 55, 17, 21, 55, 55 }; IEnumerableint> distinctAges = ages.Distinct(); Co
C#中 Lambda语法实现范围分组查询
qq_33529095的博客
09-08 1140
今天有时间查看了一下C#的教程，发现个有意思的算法。如果你是个老师，需要对班里的学生考试成绩进行分类查询，每10分一个档。这是不是想想也头疼，改如何实现呢，而且语法又要优美。微软官方网站给出了不错的示例，一起来学习一下。 1、首先定义类和数据。 public class StudentClass { #region data protected enum GradeLevel { FirstYear = 1, SecondYear, ThirdYear, FourthYear }; pro...
C#高级编程：LINQ提供程序详解与Lambda表达式应用
LINQ (Language Integrated Query) 是.NET框架的一个强大特性，它允许开发者使用类似SQL的语法进行编程，通过标准的查询操作符来处理集合和数据源。 首先，文档提到.NET 4包含多个LINQ提供程序，它们针对不同的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值