C#基础学习（三）LINQ和Lambda表达式

What is LINQ?

介绍一下LINQ(Language Integrated Query)语言集成查询
统一方式编写各种查询，检索和保存来自不同数据源的数据
消除了编程语言和数据库之间的不匹配，以及为不同类型的数据源提供单个查询入口
具体的有 LINQ to Object, xml，ADO.NET, SQL, DATASet, Entities。

有两种语法，查询表达式语法和方法语法
第一种类似于SQL语句，第二种经常会配合Lambda表达式一起使用

查询表达式以from开头，以select或group字句结束，var可以保存查询结果

方法语法就是扩展方法和Lambda表达式

What is Lambda?

再说一下Lambda表达式,看了一定学的会

语法就是（参数列表）=>{方法体}
是由委托匿名方法变化而来，看一下演变过程就明白了
delegate (int item){return item % 2 == 0;}
去掉关键字和参数类型(item)=>{return item%2 ==0;}
因为只有一个返回，可以去掉花括号，返回和分号
(item)=>item % 2 == 0;
只有一个参数，去掉括号
item => item%2 == 0;
一个优雅的lambda表达式诞生了。
多参数就加()
多返回加{ }
可以加参数类型，可以无参。
()=>Console.WriteLine("");

继续说LINQ

LINQ的基本操作有以下14种，最后会有代码举例

排序：
{
OrderBy 升序
OrderByDescending 降序
ThenBy 按升序执行次要排序
ThenByDescending 按降序执行次要排序
Reverse 颠倒顺序
}

SET操作
{
Distinct 返回的序列包含输入序列的唯一元素，去重
Except 返回的序列只包含位于第一个输入序列但不位于第二个输入序列的元素，返回差集
Intersect ： 返回的序列包含两个输入序列共有的元素，返回交集
Union： 返回的序列包含两个输入序列的唯一的元素，返回并集
}

过滤操作
{
OfType ：根据值强制转换为指定类型的能力选择值
Where： 选择基于谓词函数的值
}

量词操作
{
All ：确定是否序列中的所有元素都满足条件。
Any ：确定序列中是否有元素满足条件。
Contains : 确定序列是否包含指定的元素
}
投影操作
{
Select：映射基于转换函数的值。
SelectMany ：映射基于转换函数的值序列，然后将它们展平为一个序列。
}

划分数据
{
Skip ：跳过序列中的指定位置之前的元素。
SkipWhile ：基于谓词函数跳过元素，直到某元素不再满足条件。
Take：提取序列中的指定位置之前的元素。
TakeWhile：基于谓词函数提取元素，直到某元素不再满足条件。
}
联接操作
{
Join：根据键选择器函数联接两个序列并提取值对。
GroupJoin ：根据键选择器函数联接两个序列，并对每个元素的结果匹配项进行分组。
}
分组操作
{
GroupBy：对共享公共特性的元素进行分组。 每个组都由一个 IGrouping 对象表示。
ToLookup：根据键选择器函数将元素插入到 Lookup（一个一对多字典）中。
}
生成操作
{
DefaultIfEmpty：将空集合替换为具有默认值的单一实例集合。
Empty ：返回空集合。
Range： 生成包含数字序列的集合。
Repeat：生成包含一个重复值的集合
}
等值操作
{
SequenceEqual : 通过成对地比较元素确定两个序列是否相等
}
元素操作
{
ElementAt: 返回集合中指定索引处的元素。
ElementAtOrDefault：返回集合中指定索引处的元素；如果索引超出范围，则返回默认值。
First：返回集合中的第一个元素或满足条件的第一个元素。
FirstOrDefault：返回集合中的第一个元素或满足条件的第一个元素。 如果没有这样的元素，则返回默认值。
Last：返回集合中的最后一个元素或满足条件的最后一个元素。
LastOrDefault：返回集合中的最后一个元素或满足条件的最后一个元素。 如果没有这样的元素，则返回默认值。
Single: 返回集合中的唯一元素或满足条件的唯一元素。
SingleOrDefault：返回集合中的唯一元素或满足条件的唯一元素。 如果没有这样的元素或集合不是正好包含一个元素，则返回默认值。
}
转换类型
{
AsEnumerable ：返回类型为 IEnumerable 的输入。
AsQueryable： 将（泛型）IEnumerable 转换为（泛型）IQueryable。
Cast： 将集合的元素强制转换为指定类型。
使用显式类型化的范围变量。
OfType ：根据值强制转换为指定类型的能力筛选值。
ToArray： 将集合转换为数组。 此方法强制执行查询。
ToDictionary： 根据键选择器函数将元素放入 Dictionary 中。 此方法强制执行查询。
ToList： 将集合转换为 List。 此方法强制执行查询。
ToLookup： 根据键选择器函数将元素放入 Lookup（一对多字典）中。 此方法强制执行查询。
}

串联操作
concat：串联两个序列以组成一个序列。

聚合操作
{
Aggregate：对集合值执行自定义聚合运算。
Average：计算值集合的平均值。
Count：对集合中的元素进行计数，还可以仅对满足某一谓词函数的元素进行计数。
LongCount：对大型集合中的元素进行计数，还可以仅对满足某一谓词函数的元素进行计数。
Max：确定集合中的最大值。
Min： 确定集合中的最小值。
Sum ：计算集合中值的总和。
}
以上就是基本的LINQ操作，下面是我写的部分代码示例，可供参考

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApp1
{
    class TestLinq
    {
        static void Main(string[] args)
        {
            分别输出数组中的奇数和偶数

            int[] ints = { 1, 5, 7, 8, 4, 6, 8, 9 };
            int[] intEvens = ints.Where(p => p % 2 == 0).ToArray();
            int[] intOdds = ints.Where(p => p % 2 != 0).ToArray();
            Console.WriteLine("偶数：" + string.Join(",", intEvens));
            Console.WriteLine("奇数：" + string.Join(",", intOdds));

            var words = new[] { "jerry", "y", "tom", "dasdasdsad" };

            按字符串长度正序输出

            var query = from word in words
                        orderby word.Length
                        select word;
            foreach (var word in query)
            {
                Console.WriteLine(word);

                lambda表达式 + LINQ

            }
            var query = words.OrderBy(word => word.Length);
            foreach (var word in query)
            {
                Console.WriteLine(word);
            }
            Console.ReadKey();


            数组是否包含该元素
            var query = words.Where(p => p.Contains("z"));
            foreach (var word in query)
            {
                Console.WriteLine(word);
            }
            bool hasAword = words.Contains("y");

            数组中任一元素满足条件则True
            bool hasAword = words.Any(p => p.Equals("y"));

            数组中所有元素满足条件则True
            bool hasAword = words.All(p => p.Equals("y"));
            Console.WriteLine(hasAword);


            数组中元素的第一个字母
            var query = words.Select(p => p.Substring(0, 1));
            foreach (var word in query)
            {
                Console.WriteLine(word);
            }
            返回连续2个数据
            var query = words.Take(2);
            foreach (var word in query)
            {
                Console.WriteLine(word);
            }
            返回截止到满足函数的最后一个元素
            var query = words.TakeWhile(p => p.Equals("jerry"));
            跳过两个元素
            var query = words.Skip(2);
            跳过满足条件的第一个
            var query = words.SkipWhile(p => p.Equals("jerry"));
            foreach (var word in query)
            {
                Console.WriteLine(word);
            }
            Console.ReadKey();
        }
    }
}