LINQ 和 LINQ扩展方法 (1)

LINQ函数概念：

LINQ（Language Integrated Query）是一种C#语言中的查询技术，它允许我们在代码中利用类似SQL的查询语句来利用各种数据源。这些数据源可以是集合、数组、数据库、XML文档等等。LINQ提供了一种同一的编程模型，使我们可以或许利用类似的方式来查询和利用差别类型的数据。
在C#中，LINQ重要由以下几个组成部门：

数据源（Data source）：可以是集合、数组、数据库、XML文档等等。
查询变量（Query variable）：用于存储查询效果的变量。
查询表达式（Query expression）：类似于SQL语句的查询表达式，用于描述查询的逻辑和条件。
查询利用符（Query operator）：用于执行各种查询利用，如筛选、排序、分组、投影等等。
查询效果（Query result）：查询利用的返回效果。
此中数据源，查询变量，查询效果是必选项，查询表达式，查询利用符是可选项。
LINQ 查询关键字

1.where 条件，查询的逻辑和条件，扩展where()

1. // 1.where 条件，查询的逻辑和条件，扩展where()
2. List<int> list1 = new List<int>() { 6, 4, 2, 7, 9, 0 };
3. IEnumerable<int> query = list1.Where(c => c >= 1 && c <= 5);
4. for (int i = 0; i <= query.Count() - 1; i++)
5. {
6.     Console.WriteLine(query.ToArray()[i]);  // 4,2
7. }
8. // LINQ是强类型，会根据数据源的类型推断出来查询结果的类型。
9. IEnumerable<int> query2 = from item in list1
10.                               //where item >=1 && item <= 5 // 4,2   // 并列 && ，或者|| 等于== 不等于!=, >,<,>=,<=,!
11.                               //where !(item % 2 == 0)   
12.                               //where !GetEven(item)  // 7,9
13.                           select item;
14. for (int i = 0; i <= query2.Count() - 1; i++)
15. {
16.     Console.WriteLine(query2.ToArray()[i]);
17. }
19. List<string> list2 = new List<string>() { "abc", "adf", "ef", "bga", "cdf" };
20. IEnumerable<string> query3 = from item in list2
21.                              where item.Contains("a") || item.Contains("e")   //item.Contains 查询指定字符是否出现在字符串中
22.                              select item;
23. for(int i = 0; i <= query3.Count() - 1; i++)
24. {
25.     Console.WriteLine(query3.ToArray()[i]);
26. }
29. // 1.where条件中封装的一个方法
30. private bool GetEven(int num)
31. {
32.     return num % 2 == 0;
33. }

复制代码

字符串返回效果：

2.对查询效果做筛选（显示和隐藏列）

1. // 2.对查询结果做筛选（显示和隐藏列） Select()扩展方法和select子名类似， SelectMany()类似于两个from
2. /**/
3. //创建两个整数列表：
4. List<int> list1 = new List<int>() { 1, 2, 3 };
5. List<int> list2 = new List<int>() { 4, 5, 6 };
6. //使用Select方法对list1中的每个元素进行查询，
7. var result1 = list1.Select(item => item);
8. //使用查询语法对list1中的每个元素进行查询
9. var result2 = from item in list1
10.               select item;
12. // 使用SelectMany方法查询多个数据源，item指的是list1中的每一项
13. var result3 = list1.SelectMany(item => list2);
14. // Data To Object==DTO把查询出来的数据转换成对象，目的：访问时方便，打点调用
15. var result4 = from item in list1
16.               from value in list2
17.               //select new { item,value};
18.               select new IntObject() { Key = item , Value = value };
19. // 将result4的结果转换为List<IntObject>类型的列表，并存储在result5中
20. List<IntObject> result5 = result4.ToList();
21. // 循环遍历result5列表,并打印结果
22. for ( int i = 0;i < result5.Count;i++)
23. {
24.     var obj = result5[i];
25.     Console.WriteLine($"Key:{obj.Key},Value:{obj.Value}");
26. }

复制代码

输出效果：

3. 分组  GroupBy(), group子名，into子句

1.GroupBy（）自己具有延迟执行的特性，而ToLookup()没有。

1. List<string> sequence = new List<string>() { "a", "b", "b", "c", "c" };
2. // GroupBy(o => o)是一个 lambda 表达式，用于指定 GroupBy 方法分组的依据
3. var group = sequence.GroupBy(o => o);  // 默认GroupBy统计的是Count
4. foreach (var g in group)
5. {
6.     Console.WriteLine("Key:{0}, Count:{1}", g.Key, g.Count());
7. }

复制代码

输出效果：

这表明"a" 出现了 1 次，"b" 出现了 2 次，"c" 出现了 2 次。
PS: GroupBy(o => o) 作为 GroupBy 方法的键选择器，是一种简便且直观的方式来按元素的值举行分组。这种写法不仅代码简便，而且易于明白和维护。
2.group子名，into子句

group ... by ... into ...这是一个查询表达式，用于将数据源中的元素按照指定的键选择器举行分组。这种查询表达式是LINQ（Language Integrated Query）的一部门，它允许你以声明式的方式对集合举行查询和利用。

1. // 使用LINQ 进行数据分组和查询
2. // 1.使用了LINQ的查询语法，对一个名为sequence的序列进行操作。
3. // 2.通过group item by item语句，将序列中的元素按照它们的值进行分组。每个元素的值作为分组的键。
4. // 3.通过into groupResult子句，将分组的结果存储在一个名为groupResult的变量中。
5. // 4.使用foreach循环遍历查询结果，即遍历每个分组。
6. // 5.在foreach循环中，使用Console.WriteLine方法打印每个分组的键（即分组的值）和分组中元素的数量。
7. List<string> sequence = new List<string>() { "a", "b", "b", "c", "c" };
9. // 第一段代码：
10. var result = from item in sequence
11.              group item by item into groupResult  // into子句：把分组的结果保存到一个变量中，方便取分组的结果
12.              select groupResult;
14. foreach (var item in result)
15. {
16.     Console.WriteLine($"Key:{item.Key}, Count:{item.Count()}");
17. }
19. // 第二段代码（省略了into子句，）
20. var resulta = from item in sequence
21.               group item by item;
23. foreach (var item in resulta)
24. {
25.     Console.WriteLine($"Key:{item.Key}, Count:{item.Count()}");
26. }

复制代码

 4. ToLookup()  扩展方法来将数据集合分组

 ToLookup() 相当于group by into    GroupBy()相当于group by 

• 数据分组：ToLookup提供了一种方便的方式来根据某个属性对集合中的元素举行分组，这在处理需要按类别或属性分组的数据时非常有效。当你需要根据某个属性或条件将数据集合分成多个小组时，可以利用ToLookup。
  

• 数据展示：在分组后，可以遍历这些分组，对每个分组举行特定的利用，如盘算、展示等。
  

1. // 方式一： 使用ToLookup()
2. // 创建了一个Person对象的列表，每个Person对象包含姓名（Name）、分数（Score）和组别（Group）。
3. var nameValueScore = new Person[]
4. {
5.     new Person(){Name = "张三",Score = 80,Group = "A"},
6.     new Person(){Name = "李四",Score = 76,Group = "B"},
7.     new Person(){Name = "王五",Score = 94,Group = "A"}
8. };
10. // 使用ToLookup进行分组
11. var lookupValues = nameValueScore.ToLookup(p => p.Group);
12. // 遍历分组结果
13. foreach (var g in lookupValues)   // 循环每一组
14. {
15.     Console.WriteLine($"组名:{g.Key}");
16.     foreach (var item in g)   // 循环一组中的多个人
17.     {
18.         Console.WriteLine($"姓名：{item.Name},分数：{item.Score},分组：{item.Group}");
19.     }
20. }
21. //外层的foreach循环遍历lookupValues中的每个分组（即每个组别）。
22. //内层的foreach循环遍历每个分组中的所有Person对象，并打印出每个人的姓名、分数和组别。
24. // 方式二： 使用group...by...into...
25. var result = from p in nameValueScore
26.               group p by p.Group into g
27.               select g;
28. foreach (var g in lookupValues)   // 循环每一组
29. {
30.      Console.WriteLine($"组名:{g.Key}");
31.      foreach (var item in g)   // 循环一组中的多个人
32.      {
33.          Console.WriteLine($"姓名：{item.Name},分数：{item.Score},分组：{item.Group}");
34.      }
35. }

复制代码

输出效果：

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。