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.where 条件，查询的逻辑和条件，扩展where()
List<int> list1 = new List<int>() { 6, 4, 2, 7, 9, 0 };
IEnumerable<int> query = list1.Where(c => c >= 1 && c <= 5);
for (int i = 0; i <= query.Count() - 1; i++)
{
    Console.WriteLine(query.ToArray()[i]);  // 4,2 
}
// LINQ是强类型，会根据数据源的类型推断出来查询结果的类型。
IEnumerable<int> query2 = from item in list1
                              //where item >=1 && item <= 5 // 4,2   // 并列 && ，或者|| 等于== 不等于!=, >,<,>=,<=,!
                              //where !(item % 2 == 0)   
                              //where !GetEven(item)  // 7,9
                          select item;
for (int i = 0; i <= query2.Count() - 1; i++)
{
    Console.WriteLine(query2.ToArray()[i]);
}

List<string> list2 = new List<string>() { "abc", "adf", "ef", "bga", "cdf" };
IEnumerable<string> query3 = from item in list2
                             where item.Contains("a") || item.Contains("e")   //item.Contains 查询指定字符是否出现在字符串中
                             select item;
for(int i = 0; i <= query3.Count() - 1; i++)
{
    Console.WriteLine(query3.ToArray()[i]);
}


// 1.where条件中封装的一个方法
private bool GetEven(int num)
{
    return num % 2 == 0;
}

字符串返回结果：

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

// 2.对查询结果做筛选（显示和隐藏列） Select()扩展方法和select子名类似， SelectMany()类似于两个from
/**/
//创建两个整数列表：
List<int> list1 = new List<int>() { 1, 2, 3 };
List<int> list2 = new List<int>() { 4, 5, 6 };
//使用Select方法对list1中的每个元素进行查询，
var result1 = list1.Select(item => item);
//使用查询语法对list1中的每个元素进行查询
var result2 = from item in list1
              select item;

// 使用SelectMany方法查询多个数据源，item指的是list1中的每一项
var result3 = list1.SelectMany(item => list2);
// Data To Object==DTO把查询出来的数据转换成对象，目的：访问时方便，打点调用
var result4 = from item in list1
              from value in list2
              //select new { item,value};
              select new IntObject() { Key = item , Value = value };
// 将result4的结果转换为List<IntObject>类型的列表，并存储在result5中
List<IntObject> result5 = result4.ToList();
// 循环遍历result5列表,并打印结果
for ( int i = 0;i < result5.Count;i++)
{
    var obj = result5[i];
    Console.WriteLine($"Key:{obj.Key},Value:{obj.Value}");
}

输出结果：

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

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

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

输出结果：

这表明"a" 出现了 1 次，"b" 出现了 2 次，"c" 出现了 2 次。

PS: GroupBy(o => o) 作为 GroupBy 方法的键选择器，是一种简洁且直观的方式来按元素的值进行分组。这种写法不仅代码简洁，而且易于理解和维护。

2.group子名，into子句

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

// 使用LINQ 进行数据分组和查询
// 1.使用了LINQ的查询语法，对一个名为sequence的序列进行操作。
// 2.通过group item by item语句，将序列中的元素按照它们的值进行分组。每个元素的值作为分组的键。
// 3.通过into groupResult子句，将分组的结果存储在一个名为groupResult的变量中。
// 4.使用foreach循环遍历查询结果，即遍历每个分组。
// 5.在foreach循环中，使用Console.WriteLine方法打印每个分组的键（即分组的值）和分组中元素的数量。
List<string> sequence = new List<string>() { "a", "b", "b", "c", "c" };

// 第一段代码：
var result = from item in sequence
             group item by item into groupResult  // into子句：把分组的结果保存到一个变量中，方便取分组的结果
             select groupResult;

foreach (var item in result)
{
    Console.WriteLine($"Key:{item.Key}, Count:{item.Count()}");
}

// 第二段代码（省略了into子句，）
var resulta = from item in sequence
              group item by item;

foreach (var item in resulta)
{
    Console.WriteLine($"Key:{item.Key}, Count:{item.Count()}");
}

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

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

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

• 数据展示：在分组后，可以遍历这些分组，对每个分组进行特定的操作，如计算、展示等。

// 方式一： 使用ToLookup()
// 创建了一个Person对象的列表，每个Person对象包含姓名（Name）、分数（Score）和组别（Group）。
var nameValueScore = new Person[]
{
    new Person(){Name = "张三",Score = 80,Group = "A"},
    new Person(){Name = "李四",Score = 76,Group = "B"},
    new Person(){Name = "王五",Score = 94,Group = "A"}
};

// 使用ToLookup进行分组
var lookupValues = nameValueScore.ToLookup(p => p.Group);
// 遍历分组结果
foreach (var g in lookupValues)   // 循环每一组
{
    Console.WriteLine($"组名:{g.Key}");
    foreach (var item in g)   // 循环一组中的多个人
    {
        Console.WriteLine($"姓名：{item.Name},分数：{item.Score},分组：{item.Group}");
    }
}
 //外层的foreach循环遍历lookupValues中的每个分组（即每个组别）。
//内层的foreach循环遍历每个分组中的所有Person对象，并打印出每个人的姓名、分数和组别。

// 方式二： 使用group...by...into...
 var result = from p in nameValueScore
              group p by p.Group into g
              select g;
 foreach (var g in lookupValues)   // 循环每一组
 {
     Console.WriteLine($"组名:{g.Key}");
     foreach (var item in g)   // 循环一组中的多个人
     {
         Console.WriteLine($"姓名：{item.Name},分数：{item.Score},分组：{item.Group}");
     }
 }

输出结果：