【.NET Core】Linq查询运算符（一）

文章目录

【.NET Core】Linq查询运算符（一）
- 一、概述
- 二、筛选数据
- 三、投影运算
- - - 3.1 Select
  - 3.2 SelectMany
  - 3.3 Zip
  - 3.4 Select 与 SelectMany
- 四、Set（设置）运算
- - 4.1 Distinct或DistinctBy
  - 4.2 Except或ExceptBy
  - 4.3 Intersect或IntersectBy
  - 4.4 Union或UnionBy
- 五、对数据进行排序
- - 5.1 OrderBy
  - 5.2 OrderByDescending
  - 5.3 ThenBy
  - 5.4 ThenByDescending
  - 5.5 Reverse()
- 六、限定符运算
- - 6.1 All
  - 6.2 Any
  - 6.2 Contains
- 七、数据分区
- - 7.1 Skip
  - 7.2 SkipWhile
  - 7.3 Take
  - 7.4 TakeWhile
  - 7.5 Chunk

一、概述

查询运算符是组成Linq模式的方法。这些方法中的大多数都作用于序列；其中序列指其类型实现IEnumberable<T>接口或IQueryable<T>接口的对象。标准查询运算符提供包括筛选、投影、集合、排序等查询功能。

查询运算符包含两组，一组作用于类型IEnumberable<T>的对象，另一组作用于类型IQueryable<T>的对象。

二、筛选数据

筛选是指将结果集限制为仅包含满足指定条件的元素的操作。它也称为选定内容。筛选数据方法包含OfType和Where。

c#">string[] list=["A","AB","BC","CD","DE","EF"];
IEnumerable<string> query = from chars in list where chars.Contains("B") select chars;
foreach(string ch in query){
    Console.WriteLine(str);
}

运行结果：

AB
BC

三、投影运算

投影是指将对象转换为一种新形式的操作，该形式通常只包含那些将随后使用的属性。通过使用投影，可以构造从每个对象生成的新类型。可以投影属性，并对属性执行数学函数。

3.1 Select

c#">string[] list={"A","AB","BC","CD","DE","EF"};
IEnumerable<string> query = from chars in list select chars.ToLower();
foreach(string ch in query){
    Console.WriteLine(str)
}

运行结果

a
ab
bc
cd
de
ef

3.2 SelectMany

使用多个from子句来投影字符串列表中每个字符串的每个字符转变为大写。

string[] list =  { "A|B|C|D","E|F|G|H"};
IEnumerable<string> query = from chars in list 
                            from ch in chars.Split('|')
                            select ch;
foreach (string ch in query)
{
  Console.WriteLine(ch)     
}

运行结果

A
B
C
D
E
F
G
H

3.3 Zip

Zip投影运算符有多个重载，所有Zip方法都处理两个或更多可能是异构类型的序列。前两个重载返回元组，具有来自给定序列的响应位置类型。

c#">int[] index = { 1, 2, 3 };
string[] chars = { "A", "B", "C" };
IEnumerable<string> zip = chars.Zip(index, (n, w) => n + "=" + w);
foreach (var z in zip) 
{
   Console.WriteLine(z);
}

运行结果

A=1
B=2
C=3

zip操作生成的序列的长度永远不会长于最短序列。index和letters集合的长度不同，生成的序列将省略index集合中的最后一个元素，因为它没有任何要压缩的内容。

3.4 Select 与 SelectMany

Select与SelectMany的工作都是依据源生成一个或多个结构值。Select为每个源值生成一个结构值。因此，总体结构是一个与源集合具有相同元素数目的集合。与之相反，SelectMany 生成单个总体结果，其中包含来自每个源值的串联子集合。作为参数传递到 SelectMany 的转换函数必须为每个源值返回一个可枚举值序列。然后，SelectMany 串联这些可枚举序列，以创建一个大的序列。

四、Set（设置）运算

LINQ 中的集运算是指根据相同或不同集合（或集）中是否存在等效元素来生成结果集的查询运算。

4.1 Distinct或DistinctBy

删除集合中的重复元素

c#">int[] index = { 1, 2, 3 ,4};
string[] chars = { "A", "B", "C" , "B", "C" ,"D"};
IEnumerable<string> zip = from ch in chars.Distinct() select ch;
foreach (var z in zip) 
{
     Console.WriteLine(z);
}

运行结果

A
B
C
D

在新.NET Framework中可以使用DistinctBy替代Distinct,DistinctBy采用keySelector。keySelector用作源类型的比较鉴别器。

4.2 Except或ExceptBy

Except返回的序列只包含位于第一个输入序列但不位于第二个输入序列的元素。

c#">string[] listA = { "A", "B", "AC", "BC", "CD" };
string[] chars = { "A", "B", "C" , "B", "C" ,"D"};
IEnumerable<string> listC = from ch in chars.Except(listA) select ch;
foreach (var z in listC) 
{
    Debug.WriteLine(z);
}

运行结果

C
D

ExceptBy 方法是 Except 的替代方法，它采用可能是异构类型的两个序列和一个 keySelector。 keySelector 与第二个集合的类型相同，用作源类型的比较鉴别器。

4.3 Intersect或IntersectBy

返回序列包含两个输入序列共有的元素。

c#">string[] listA = { "A", "B", "AC", "BC", "CD" };
string[] chars = { "A", "B", "C" , "B", "C" ,"D"};
IEnumerable<string> listC = from ch in chars.Intersect(listA) select ch;
foreach (var z in listC) 
{
    Debug.WriteLine(z);
}

运行结果

A
B

IntersectBy方法是Intersect的替代方法，它采用可能是异构类型的两个序列和一个keySelector。keySelector用作第二个集合类型的比较鉴别器。

4.4 Union或UnionBy

两个字符串序列执行的联合操作。返回的序列包含两个输入序列的唯一元素。

c#">string[] listA = { "A", "B", "AC", "BC", "CD" };
string[] chars = { "A", "B", "C" , "B", "C" ,"D"};
IEnumerable<string> listC = from ch in chars.Union(listA) select ch;
foreach (var z in listC) 
{
     Debug.WriteLine(z);
}

运行结果

c#">A
B
C
D
AC
BC
CD

五、对数据进行排序

排序操作基于一个或多个属性对序列的元素进行排序。第一个排序条件对元素执行主要排序。通过指定第二个排序条件，您可以对每个主要排序组内的元素进行排序。

5.1 OrderBy

结果集按升序对值排序。

c#">string[] listA = { "A", "B", "AC", "BC", "CD" };
string[] chars = { "A", "B", "C" , "B", "C" ,"D"};
IEnumerable<string> listC = from ch in chars.Union(listA) orderby ch select ch;
foreach (var z in listC) 
{
   Debug.WriteLine(z);
}

运行结果

A
AC
B
BC
C
CD
D

5.2 OrderByDescending

按降序对值排序。C#查询表达式语法orderby… descending

c#">string[] listA = { "A", "B", "AC", "BC", "CD" };
string[] chars = { "A", "B", "C" , "B", "C" ,"D"};
IEnumerable<string> listC = from ch in chars.Union(listA) 
                            orderby ch descending 
                            select ch;
foreach (var z in listC) 
{
     Debug.WriteLine(z);
}

运行结果

c#">D
CD
C
BC
B
AC
A

5.3 ThenBy

按升序执行次要排序。orderby...,...

c#">string[] listA = { "A", "B", "AC", "BC", "CD" };
string[] chars = { "A", "B", "C" , "B", "C" ,"D"};
IEnumerable<string> listC = from ch in chars.Union(listA) orderby ch,ch.Length select ch;
foreach (var z in listC) 
{
   Debug.WriteLine(z);
}

运行结果

A
AC
B
BC
C
CD
D

5.4 ThenByDescending

按降序执行次要顺序。C#查询表达式语法orderby…,… descending。

c#">string[] listA = { "AB", "DC", "ED", "FH", "Z" };
IEnumerable<string> listC = from ch in listA
                            orderby ch descending,ch.Length  descending
                            select ch;
foreach (var z in listC) 
{
    Debug.WriteLine(z);
}

运行结果

Z
FH
ED
DC
AB

5.5 Reverse()

反转集合中元素的顺序

c#">string[] listA = { "AB", "DC", "ED", "FH", "Z" };
IEnumerable<string> listC = listA.Reverse();
foreach (var z in listC) 
{
     Debug.WriteLine(z);
}

运行结果

Z
FH
ED
DC
AB

六、限定符运算

限定符运算返回一个Boolean值，该值指示序列中是否有一些元素满足条件或是否所有元素都满足条件。

6.1 All

全部确定是否序列中的所有元素都满足条件

c#">class Marketing
{
   public string Name{get;set;}
   public string[] Items{get;set;}
}
public static void Main(string[] args)
{
   List<Marketing> markets=
   {
       new Market { Name = "Emily's", Items = {"kiwi", "cheery", "banana"} },
       new Market { Name = "Kim's", Items = {"melon", "mango", "olive"} },
       new Market { Name = "Adam's", Items = {"kiwi", "apple", "orange"} },
   } 
   var names = from marker in markets
               where marker.Items.All(item=>item.Length == 5)
               select Name;
    foreach(string name in namse)
    {
        Debug.WriteLine(name);
    }
}

6.2 Any

使用Any检查所有字符串是否以“o”开头。

c#">class Market
{
    public string Name{get;set;}
    public string[] Items{get;set;}
}
public static void Main(string[] args)
{
    List<Market> markets=
    {
       new Market { Name = "Emily's", Items = {"kiwi", "cheery", "banana"}},
       new Market { Name = "Kim's", Items = {"melon", "mango", "olive"} },
       new Market { Name = "Adam's", Items = {"kiwi", "apple", "orange"} },  
    }
    IEnumerable<string> names = from market in markets
                                where market.Items.Any(item=>item.StartsWith("o"))
                                select market.Name;
    foreach(string name in names)
    {
        Debug.WriteLine(name);
    }
}

6.2 Contains

Contains检查所有数组是否具有特定元素。

class Market
{
    public string Name{get;set;}
    public string[] Items{get;set;}
}
public static void Main(string[] args)
{
    List<Market> markets=
    {
       new Market { Name = "Emily's", Items = {"kiwi", "cheery", "banana"}},
       new Market { Name = "Kim's", Items = {"melon", "mango", "olive"} },
       new Market { Name = "Adam's", Items = {"kiwi", "apple", "orange"} },  
    }
    IEnumerable<string> names = from market in markets
                                where market.Items.Contains("kiwi")
                                select market.Name;
    foreach(string name in names)
    {
        Debug.WriteLine(name);
    }
}

七、数据分区

Linq中的数据分区是指将输入序列划分为两个部分的操作，无需重新排列元素，然后返回其中一个部分。

7.1 Skip

Skip跳过序列中指定位置之前的元素。

c#">string[] items ={"A", "B","C","D","E","F","G","H","I"};
var item= items.Skip(5);
foreach (var it in item) 
{
    Console.WriteLine(it);
}

运行结果

F
G
H
I

7.2 SkipWhile

Skip指定跳过的数目，SkipWhile指定的跳过条件，而不是元素数。

c#">string[] texts = new string[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
IEnumerable<string> skippedTexts = texts.SkipWhile(value => value.EndsWith("n"));
foreach (var it in skippedTexts) 
{
   Console.WriteLine(it);
}

运行结果

Tue
Wed
Thu
Fri
Sat

7.3 Take

获取序列中指定位置之前的元素

c#">string[] texts = new string[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
// 删除尾字母为n的
IEnumerable<string> skippedTexts = texts.Take(3);
foreach (var it in skippedTexts) 
{
    Console.WriteLine(it);
}

运行结果

Sun
Mon
Tue

7.4 TakeWhile

TakeWhile操作符用于从输入序列中返回指定数量且满足一定条件的元素。

当TakeWhile操作符被调用时，会将source序列中的每一个元素顺序传递给委托predicate,只有哪些使用得predicate返回值为true的元素才会被添加到结果序列中，要特别注意是，当TakeWhile操作符在查找过程中，遇到第一个返回false的元素就会立即停止执行，跳出，无论后面还有没有符合条件的元素，即使后面有符合条件的元素也不会获取。对于第二个扩展方法，委托里面含有一个int类型的参数。

c#">string[] lists = ["a", "e", "i", "o", "u"];
var takeList = lists.TakeWhile(x => x != "i");
foreach (var al in takeList) 
{
    Console.WriteLine(al);
}

运行结果

a
e

7.5 Chunk

chunk 该方法将序列的元素拆分为指定大小的区块

c#">string[] lists = {"公孙胜","鲁智深","林冲","吴用","李逵","宋江","武松" };
var nameList = lists.Chunk(3);
foreach (var names in nameList) 
{
    foreach (var name in names) 
    {
        Trace.WriteLine(name);
    }
    Trace.WriteLine("****************");
}

运行结果

公孙胜
鲁智深
林冲
****************
吴用
李逵
宋江
****************
武松
****************