C# LINQ学习笔记二：LINQ标准查询操做概述

时间 2019-12-26

标签 c# linq 学习笔记标准查询概述栏目 C# 繁體版

原文原文链接

本笔记摘抄自：http://www.javashuo.com/article/p-gggkizop-dc.html，记录一下学习过程以备后续查用。html

“标准查询运算符”是组成语言集成查询 (LINQ) 模式的方法，大多数这些方法都在序列上运行，其中的序列是一个对象，其类型实现了IEnumerable<T>接口数据库

或 IQueryable<T> 接口。标准查询运算符提供了包括筛选、投影、聚合、排序等功能在内的查询功能，各个标准查询运算符在执行时间上有所不一样，具体状况编程

取决于它们是返回单一值仍是值序列：数组

返回单一值的方法（例如Average和Sum）会当即执行，返回序列的方法会延迟查询执行，并返回一个可枚举的对象。 app

对于在内存中集合上运行的方法（即扩展IEnumerable<T>的方法），返回的可枚举对象将捕获传递到方法的参数。在枚举该对象时，将使用查询运算符的框架

逻辑，并返回查询结果。与之相反，扩展IQueryable<T>的方法不会实现任何查询行为，但会生成一个表示要执行的查询的表达式树，查询处理由源ide

IQueryable<T>对象处理。函数

1、按标准执行方式分类学习

标准查询运算符方法的LINQ to Objects实现采用两种主要方式之一来执行：当即执行和延迟执行，采用延迟执行的查询运算符能够进一步分为两类：流式和ui

非流式。

一、执行方式

当即执行：当即执行意味着在代码中声明查询的位置读取数据源并执行运算，返回单个不可枚举的结果的全部标准查询运算符都当即执行。

延迟执行：延迟执行意味着不在代码中声明查询的位置执行运算，仅当对查询变量进行枚举操做时才执行运算，例如经过使用foreach语句，这意味着查询的

执行结果取决于执行查询而非定义查询时的数据源内容。若是屡次枚举查询变量，则每次结果可能都不一样。几乎全部返回类型为IEnumerable<T>或

IOrderedEnumerable<TElement>的标准查询运算符都以延迟方式执行。

二、延迟执行

流式：运算符不须要在生成元素前读取全部源数据。在执行时，流式运算符一边读取每一个源元素，一边对该源元素执行运算，并在可行时生成元素，流式运

算符将持续读取源元素直到能够生成结果元素，这意味着可能要读取多个源元素才能生成一个结果元素。

非流式：运算符必须读取全部源数据才能生成结果元素，诸如排序和分组等运算属于此类别。在执行时，非流式查询运算符读取全部源数据，将其放入数据

结构中，执行运算而后生成结果元素。

2、排列数据

排序操做按一个或多个特性对序列的元素进行排序。第一个排序条件对元素执行主要排序，经过指定第二个排序条件，能够对各个主要排序组中的元素进行

排序。
下图演示对一个字符序列按字母排序操做的执行结果：

标准查询运算符操做方法 - 排序
方法名	说明	C# 查询表达式语法
OrderBy	按升序对值进行排序。	orderby
OrderByDescending	按降序对值进行排序。	orderby … descending
ThenBy	按升序执行次要排序。	orderby …, …
ThenByDescending	按降序执行次要排序。	orderby …, … descending
Reverse	颠倒集合中的元素的顺序。	X

下面代码演示orderby升序排序：

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ orderby升序排序
            var words = new[] { "the", "quick", "brown", "fox", "jumps" };
            var query = 
                from word in words
                orderby word.Length
                select word;
            foreach (var word in query)
            {
                Console.WriteLine(word);
            }
            Console.Read();
            #endregion
        }
    }

View Code

运行结果以下：

下面代码演示orderby降序排序：

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ orderby降序排序
            var words = new[] { "the", "quick", "brown", "fox", "jumps" };
            var query = 
                from word in words
                orderby word.Substring(0, 1) descending
                select word;
            foreach (var word in query)
            {
                Console.WriteLine(word);
            }
            Console.Read();
            #endregion
        }
    }

View Code

运行结果以下：

下面代码演示orderby主要和次要排序（示例一）：

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ orderby主要和次要排序示例一
            var words = new[] { "the", "quick", "brown", "fox", "jumps" };
            var query = 
                from word in words
                orderby word.Length, word.Substring(0, 1)
                select word;
            foreach (var word in query)
            {
                Console.WriteLine(word);
            }
            Console.Read();
            #endregion
        }
    }

View Code

运行结果以下：

下面代码演示orderby主要和次要排序（示例二）：

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ orderby主要和次要排序示例二
            var words = new[] { "the", "quick", "brown", "fox", "jumps" };
            var query = 
                from word in words
                orderby word.Length, word.Substring(0, 1) descending
                select word;
            foreach (var word in query)
            {
                Console.WriteLine(word);
            }
            Console.Read();
            #endregion
        }
    }

View Code

运行结果以下：

3、Set 操做

LINQ中的Set操做是指根据相同或不一样集合中是否存在等效元素来生成结果集的查询操做。

标准查询运算符操做方法 - Set
方法名	说明	C# 查询表达式语法
Distinct	从集合移除重复值。	X
Except	返回差集，差集是指位于一个集合但不位于另外一个集合的元素。	X
Intersect	返回交集，交集是指同时出如今两个集合中的元素。	X
Union	返回并集，并集是指位于两个集合中任一集合的惟一的元素。	X

图解Set操做

一、Distinct：返回的序列包含输入序列的惟一元素。

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

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

四、Union：返回的序列包含两个输入序列的惟一的元素。

4、过滤数据

筛选指将结果集限制为只包含某些知足指定条件的元素的操做，它又称为选择。

下图演示了对字符序列进行筛选的结果，筛选操做的谓词指定字符必须为“A”。

标准查询运算符操做方法 - 筛选
方法名	说明	C# 查询表达式语法
OfType	根据值强制转换为指定类型的能力选择值。	X
Where	选择基于谓词函数的值。	where

下面代码演示过滤数据：

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 过滤数据
            string[] words = { "the", "quick", "brown", "fox", "jumps" };
            var query = 
                from word in words
                where word.Length == 3
                select word;
            foreach (var word in query)
            {
                Console.WriteLine(word);
            }
            Console.Read();
            #endregion
        }
    }

View Code

运行结果以下：

5、量词操做

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

下图描述了两个不一样源序列上的两个不一样限定符运算。第一个运算询问是否有一个或多个元素为字符“A”，结果为true，第二个运算询问是否全部元素都为字

符“A”，结果为true。

标准查询运算符操做方法 - 量词
方法名	说明	C# 查询表达式语法
All	肯定是否序列中的全部元素都知足条件。	X
Any	肯定序列中是否有元素知足条件。	X
Contains	肯定序列是否包含指定的元素。	X

6、投影操做

投影是指将对象转换为一种新形式的操做，该形式一般只包含那些将随后使用的属性。经过使用投影，您能够构建依据每一个对象生成的新类型，还能够映射

属性，并对该属性执行数学函数，另外还能够在不更改原始对象的状况下映射该对象。

标准查询运算符操做方法 - 投影
方法名	说明	C# 查询表达式语法
Select	映射基于转换函数的值。	select
SelectMany	映射基于转换函数的值序列，而后将它们展平为一个序列。	使用多个 from 子句

下面代码演示Select：

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ Select
            var words = new[] { "the", "quick", "brown", "fox", "jumps" };
            var query = 
                from word in words
                select word.Substring(0, 1);
            foreach (var word in query)
            {
                Console.WriteLine(word);
            }
            Console.Read();
            #endregion
        }
    }

View Code

运行结果以下：

下面代码演示SelectMany：

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ SelectMany
            var phrases = new List<string>() { "an apple a day", "the quick brown fox" };
            var query = 
                from phrase in phrases
                    from word in phrase.Split(' ')
                    select word;
            foreach (var word in query)
            {
                Console.WriteLine(word);
            }
            Console.Read();
            #endregion
        }
    }

View Code

运行结果以下：

Select()和SelectMany()的工做都是依据源值生成一个或多个结果值。Select()为每一个源值生成一个结果值。所以，整体结果是一个与源集合具备相同元素数

目的集合。与之相反，SelectMany()将生成单一整体结果，其中包含来自每一个源值的串联子集合。做为参数传递到SelectMany()的转换函数必须为每一个源值返

回一个可枚举值序列，而后，SelectMany() 将串联这些可枚举序列以建立一个大的序列。

下面两个插图演示了这两个方法的操做之间的概念性区别。在每种状况下，假定选择器（转换）函数从每一个源值中选择一个由花卉数据组成的数组。

下图描述 Select() 如何返回一个与源集合具备相同元素数目的集合。

下图描述SelectMany()如何将中间数组序列串联为一个最终结果值，其中包含每一个中间数组中的每一个值。

下面的示例比较Select()和SelectMany()的行为。代码将经过从源集合的每一个花卉名称列表中提取前两项来建立一个“花束”。在此示例中，转换函数Select使用

的“单一值”自己就是一个值集合。这须要额外的foreach循环，以便枚举每一个子序列中的每一个字符串。

    /// <summary>
    /// 花束类
    /// </summary>
    class Bouquet
    {
        public List<string> Flowers { get; set; }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ Select和SelectMany比较
            var bouquets = new List<Bouquet>()
            {
                new Bouquet {Flowers = new List<string> {"sunflower", "daisy", "daffodil", "larkspur"}},
                new Bouquet {Flowers = new List<string> {"tulip", "rose", "orchid"}},
                new Bouquet {Flowers = new List<string> {"gladiolis", "lily", "snapdragon", "aster", "protea"}},
                new Bouquet {Flowers = new List<string> {"larkspur", "lilac", "iris", "dahlia"}}
            };

            IEnumerable<List<string>> query1 = bouquets.Select(bq => bq.Flowers);
            IEnumerable<string> query2 = bouquets.SelectMany(bq => bq.Flowers);

            Console.WriteLine("query1->Select():");
            foreach (IEnumerable<string> collection in query1)
            {
                foreach (var item in collection)
                {
                    Console.WriteLine(item);
                }
            }

            Console.WriteLine("\nquery2->SelectMany():");
            foreach (var item in query2)
            {
                Console.WriteLine(item);
            }

            Console.Read();
            #endregion
        }
    }

View Code

运行结果以下：

7、划分数据

LINQ 中的分区指的是在不从新排列元素的状况下，将输入序列划分为两部分，而后返回其中一个部分的操做。

下图显示对一个字符序列执行三个不一样的分区操做的结果。第一个操做返回序列中的前三个元素；第二个操做跳过前三个元素，返回剩余的元素；第三个操做

跳过序列中的前两个元素，返回接下来的三个元素。

分区序列的标准查询运算符方法
运算符名称	说明	C# 查询表达式语法
Skip	跳过序列中的指定位置以前的元素。	X
SkipWhile	基于谓词函数跳过元素，直到某元素再也不知足条件。	X
Take	提取序列中的指定位置以前的元素。	X
TakeWhile	基于谓词函数提取元素，直到某元素再也不知足条件。	X

8、联接操做

将两个数据源“联接”就是将一个数据源中的对象与另外一个数据源中共享某个通用特性的对象关联起来。

当查询所面向的数据源相互之间具备没法直接领会的关系时，联接就成为一项重要的运算。在面向对象的编程中，这可能意味着在未建模对象之间进行关联，

例如对单向关系进行反向推理。

LINQ 框架中提供的联接方法包括Join和GroupJoin。这些方法执行同等联接，即根据两个数据源的键是否相等来匹配这两个数据源的联接。（与此相较，

Transact-SQL支持除“等于”以外的联接运算符，例如“小于”运算符。）用关系数据库术语表达，就是说Join实现了内部联接，这种联接只返回那些在另外一个数据集

中具备匹配项的对象。GroupJoin方法在关系数据库术语中没有直接的等效项，但它实现了内部联接和左外部联接的超集。左外部联接是这样一种联接：它返回第

一个（左）数据源的每一个元素，即便该元素在另外一个数据源中没有关联元素。

下图显示了一个概念性视图，其中包含两个集合以及这两个集合中的包含在内部联接或左外部联接中的元素。

标准查询运算符操做方法 - 联接
方法名	描述	C# 查询表达式语法
Join	根据键选择器函数联接两个序列并提取值对。	join … in … on … equals …
GroupJoin	根据键选择器函数联接两个序列，并对每一个元素的结果匹配项进行分组。	join … in … on … equals … into …

9、分组数据

分组指将数据放入组中以便每一个组中的元素共享公共特性的操做。

下图显示了对字符序列进行分组的结果，每一个组的键是字符。

标准查询运算符方法 - 分组
方法名	说明	C# 查询表达式语法
GroupBy	对共享公共特性的元素进行分组。每一个组都由一个 IGrouping<TKey, TElement> 对象表示。	group … by - 或 - group … by … into …
ToLookup	根据键选择器函数将元素插入到 Lookup<TKey, TElement>（一个一对多字典）中。	X

下面代码演示分组数据：

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 分组数据
            var numbers = new List<int>() { 35, 44, 200, 84, 3987, 4, 199, 329, 446, 208 };
            IEnumerable<IGrouping<bool, int>> query = from number in numbers
                                                      group number by number % 2 == 0;
            foreach (var group in query)
            {
                Console.WriteLine($"{(group.Key ? "偶数" : "基数")}：");
                foreach (var item in group)
                {
                    Console.WriteLine(item);
                }
            }
            Console.Read();
            #endregion
        }
    }

View Code

运行结果以下：

10、生成操做

生成是指建立新的值序列。

标准查询运算符方法 - 生成
方法名	说明	C# 查询表达式语法
DefaultIfEmpty	将空集合替换为具备默认值的单一实例集合。	X
Empty	返回空集合。	X
Range	生成包含数字序列的集合。	X
Repeat	生成包含一个重复值的集合。	X

11、等值操做

若是两个序列的对应元素相等且这两个序列具备相同数量的元素，则视这两个序列相等。

标准查询运算符方法 - 等值
方法名	说明	C# 查询表达式语法
SequenceEqual	经过成对地比较元素肯定两个序列是否相等。	X

12、元素操做

元素操做从一个序列返回单个特定元素。

标准查询运算符操做方法 - 元素
方法名	说明	C# 查询表达式语法
ElementAt	返回集合中指定索引处的元素。	X
ElementAtOrDefault	返回集合中指定索引处的元素；若是索引超出范围，则返回默认值。	X
First	返回集合中的第一个元素或知足条件的第一个元素。	X
FirstOrDefault	返回集合中的第一个元素或知足条件的第一个元素。若是没有这样的元素，则返回默认值。	X
Last	返回集合中的最后一个元素或知足条件的最后一个元素。	X
LastOrDefault	返回集合中的最后一个元素或知足条件的最后一个元素。若是没有这样的元素，则返回默认值。	X
Single	返回集合中的惟一元素或知足条件的惟一元素。	X
SingleOrDefault	返回集合中的惟一元素或知足条件的惟一元素。若是没有这样的元素或集合不是正好包含一个元素，则返回默认值。	X

十3、转换数据类型

转换方法更改输入对象的类型。

LINQ查询中的转换运算可用于各类应用程序，下面是一些示例：

一、Enumerable.AsEnumerable<TSource> 方法可用于隐藏类型的标准查询运算符的自定义实现。

二、Enumerable.OfType<TResult> 方法可用于启用非参数化集合以进行LINQ查询。

三、Enumerable.ToArray<TSource>、Enumerable.ToDictionary<TSource, TKey>、Enumerable.ToList<TSource> 和 Enumerable.ToLookup<TSource, TKey>

方法可用于强制当即执行查询，而非推迟到枚举查询时。

标准查询运算符方法 - 转换数据类型
方法名	说明	C# 查询表达式语法
AsEnumerable	返回类型为 IEnumerable<T> 的输入。	X
AsQueryable	将（泛型）IEnumerable 转换为（泛型）IQueryable。	X
Cast	将集合的元素强制转换为指定类型。	使用显式类型化的范围变量。例如： from string str in words
OfType	根据值强制转换为指定类型的能力筛选值。	X
ToArray	将集合转换为数组。此方法强制执行查询。	X
ToDictionary	根据键选择器函数将元素放入 Dictionary<TKey, TValue> 中。此方法强制执行查询。	X
ToList	将集合转换为 List<T>。此方法强制执行查询。	X
ToLookup	根据键选择器函数将元素放入 Lookup<TKey, TElement>（一对多字典）中。此方法强制执行查询。	X

下面代码演示转换数据类型：

    /// <summary>
    /// 植物类
    /// </summary>
    class Plant
    {
        public string Name { get; set; }
    }

    /// <summary>
    /// 食肉植物类
    /// </summary>
    class CarnivorousPlant : Plant
    {
        public string TrapType { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 转换数据类型
            var plants = new Plant[]
            {
                new CarnivorousPlant {Name = "Venus Fly Trap", TrapType = "Snap Trap"},
                new CarnivorousPlant {Name = "Pitcher Plant", TrapType = "Pitfall Trap"},
                new CarnivorousPlant {Name = "Sundew", TrapType = "Flypaper Trap"},
                new CarnivorousPlant {Name = "Waterwheel Plant", TrapType = "Snap Trap"}
            };
            var query = from CarnivorousPlant plant in plants
                        where plant.TrapType == "Snap Trap"
                        select plant;
            foreach (var carnivorousPlant in query)
            {
                Console.WriteLine(carnivorousPlant.Name);
            }
            Console.Read();
            #endregion
        }
    }

View Code

运行结果以下：

十4、串联操做

串联是指将一个序列追加到另外一个序列的运算。

下图演示对两个字符序列执行的串联运算。

标准查询运算符操做方法 - 串联
方法名	说明	C# 查询表达式语法
Concat	串联两个序列以组成一个序列。	X

十5、聚合操做

聚合运算从值集合计算单个值。从一个月的日温度值计算日平均温度就是聚合运算的一个示例。

下图显示了对一个数字序列执行两个不一样聚合运算的结果。第一个运算对这些数字执行求和；第二个运算返回该序列中的最大值。

标准查询运算符操做方法 - 聚合
方法名	说明	C# 查询表达式语法
Aggregate	对集合值执行自定义聚合运算。	X
Average	计算值集合的平均值。	X
Count	对集合中的元素进行计数，还能够仅对知足某一谓词函数的元素进行计数。	X
LongCount	对大型集合中的元素进行计数，还能够仅对知足某一谓词函数的元素进行计数。	X
Max	肯定集合中的最大值。	X
Min	肯定集合中的最小值。	X
Sum	计算集合中值的总和。	X