C# LINQ学习笔记一：走进LINQ的世界

时间  2019-12-26
标签 c# linq 学习 笔记 走进 世界 栏目 C# 繁體版
原文   原文链接

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

    LINQ 简介：数据库

    语言集成查询(LINQ)是Visual Studio 2008和.NET Framework 3.5版中引入的一项创新功能。编程

　传统上，针对数据的查询都是以简单的字符串表示，而没有编译时类型检查或IntelliSense支持。此外，您还必须针对如下各类数据源学习一种不一样的查询数组

语言：SQL数据库、XML文档、各类Web服务等。经过LINQ，可使用语言关键字和熟悉的运算符针对强类型化对象集合编写查询。缓存

    在Visual Studio中，能够为如下数据源编写LINQ查询：SQL Server数据库、XML文档、ADO.NET数据集以及支持 IEnumerable或泛型 IEnumerable<T> 服务器

接口的任意对象集合，使用要求：项目 ≥ .NET Framework 3.5。编程语言

    1、LINQ查询ide

    查询是一种从数据源检索数据的表达式。随着时间的推移，人们已经为各类数据源开发了不一样的语言。例如，用于关系数据库的SQL和用于XML的XQuery。函数

所以，开发人员不得不针对他们必须支持的每种数据源或数据格式而学习新的查询语言。LINQ经过提供一种跨数据源和数据格式使用数据的一致模型，简化工具

了这一状况。在LINQ查询中，始终会用到对象。可使用相同的编码模式来查询和转换XML文档、SQL数据库、ADO.NET数据集、.NET集合中的数据以及

对其有LINQ提供程序可用的任何其余格式的数据。

    1.1 查询操做的三个部分

    操做三部曲：①取数据源 ②建立查询 ③执行查询

    下面代码演示LINQ to OBJECT：

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ to OBJECT
            //查询三部曲：一、获取数据源
            var nums = new int[7] { 0, 1, 2, 3, 4, 5, 6 };

            //查询三部曲：二、建立查询
            var query =
                from num in nums
                where (num % 2) == 0
                select num;

            //查询三部曲：三、执行查询
            foreach (var num in query)
            {
                Console.Write($"{num} ");
            }

            Console.Read();
            #endregion
        }
    }
View Code

    运行结果以下：

    下图显示了完整的查询操做。在LINQ中，查询的执行与查询自己大相径庭。换句话说，查询自己指的是只建立查询变量，不检索任何数据。

    1.2 数据源

    在上一个示例中(LINQ to OBJECT)，因为数据源是数组，所以它隐式支持泛型 IEnumerable<T> （可枚举）接口。支持 IEnumerable<T> 或派生接口（如

泛型IQueryable<T>）的类型称为可查询类型。

    可查询类型不须要进行修改或特殊处理就能够用做LINQ数据源。若是源数据尚未做为可查询类型出如今内存中，则LINQ提供程序必须以此方式表示源数

据。例如，LINQ to XML将XML文档加载到可查询的 XElement 类型中。

    下面代码演示LINQ to XML：

    建立一个Test.xml文件，放在主目录下。

<DocumentElement>
  <Category>
    <MO_NO>MOA1911070001</MO_NO>
    <MRP_NO>8198712090963008</MRP_NO>
    <QTY>1.00000000</QTY>
    <BIL_NO>MPA19110701</BIL_NO>
  </Category>
  <Category>
    <MO_NO>MOA1911070002</MO_NO>
    <MRP_NO>8193000000003172</MRP_NO>
    <QTY>1.00000000</QTY>
    <BIL_NO>MPA19110702</BIL_NO>
  </Category>
  <Category>
    <MO_NO>MOA1911070003</MO_NO>
    <MRP_NO>8193002043133003</MRP_NO>
    <QTY>1.00000000</QTY>
    <BIL_NO>MPA19110702</BIL_NO>
  </Category>
  <Category>
    <MO_NO>MOA1911070004</MO_NO>
    <MRP_NO>8193002043133004</MRP_NO>
    <QTY>1.00000000</QTY>
    <BIL_NO>MPA19110702</BIL_NO>
  </Category>
  <Category>
    <MO_NO>MOA1911070005</MO_NO>
    <MRP_NO>8193002043133005</MRP_NO>
    <QTY>1.00000000</QTY>
    <BIL_NO>MPA19110702</BIL_NO>
  </Category>
  <Category>
    <MO_NO>MOA1911070006</MO_NO>
    <MRP_NO>8198922092971001</MRP_NO>
    <QTY>1.00000000</QTY>
    <BIL_NO>MPA19110703</BIL_NO>
  </Category>
  <Category>
    <MO_NO>MOA1911070007</MO_NO>
    <MRP_NO>8198922092971002</MRP_NO>
    <QTY>1.00000000</QTY>
    <BIL_NO>MPA19110703</BIL_NO>
  </Category>
  <Category>
    <MO_NO>MOA1911070008</MO_NO>
    <MRP_NO>8198922092971010</MRP_NO>
    <QTY>1.00000000</QTY>
    <BIL_NO>MPA19110703</BIL_NO>
  </Category>
  <Category>
    <MO_NO>MOA1911070009</MO_NO>
    <MRP_NO>8198922092971200</MRP_NO>
    <QTY>1.00000000</QTY>
    <BIL_NO>MPA19110703</BIL_NO>
  </Category>
  <Category>
    <MO_NO>MOA1911070010</MO_NO>
    <MRP_NO>8199862094443008</MRP_NO>
    <QTY>1.00000000</QTY>
    <BIL_NO>MPA19110704</BIL_NO>
  </Category>
</DocumentElement>
View Code 
    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ to XML
            var xe = XElement.Load(@"..\..\Test.xml");
            var query =
                from item in xe.Descendants("Category")
                select item;
            foreach (var item in query)
            {
                Console.WriteLine($"MO_NO={item.Element("MO_NO").Value}");
            }
            Console.Read();
            #endregion
        }
    }
View Code

    运行结果以下：

    在LINQ to SQL中，首先须要生成对象模型映射到关系数据库，而后针对这些对象编写查询，由LINQ to SQL在运行时处理与数据库的通讯。

    准备一：下文中用到的Northwind数据库，下载地址为：https://www.microsoft.com/en-us/download/confirmation.aspx?id=23654

    准备二：若本机没有安装LINQ to SQL工具，可参考安装教程：https://blog.csdn.net/u011176794/article/details/90287293

    准备三：添加新建项，选择LINQ to SQL类，命名为Sample。

    准备四：服务器资源管理器的数据链接中，右键添加链接，依导向链接至SQL Server数据库。

    准备五：将相关数据表拖至Sample.dbml中并保存。

    准备六：添加引用System.Data.Linq。

    下面代码演示LINQ to SQL：

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ to SQL
            var db = new SampleDataContext();
            var query =
                from cust in db.Customers
                where cust.City == "London"
                select cust;
            foreach (var item in query)
            {
                Console.WriteLine($"CustomerID={item.CustomerID}");
            }
            Console.Read();
            #endregion
        }
    }
View Code

    运行结果以下：

    1.3查询

    查询指定要从数据源中检索的信息，能够指定在返回这些信息以前如何对其进行排序、分组和结构化。 查询存储在查询变量中，并用查询表达式进行初始

化。以前的示例中的查询是从整数数组中返回全部的偶数。该查询表达式包含三个子句：from、where和select。若是您熟悉SQL，您会注意到这些子句的

顺序与SQL中的顺序相反，from 子句指定数据源，where 子句指定应用筛选器，select 子句指定返回的元素的类型。目前须要注意的是，在LINQ中，查询

变量自己不执行任何操做而且不返回任何数据，它只是存储在之后某个时刻执行查询时为生成结果而必需的信息。

    1.4 查询执行

    1.延迟执行

    如前所述，查询变量自己只是存储查询命令，实际的查询执行会延迟到在foreach语句中循环访问查询变量时发生，此概念称为“延迟执行”。

    2.强制当即执行

    对一系列源元素执行聚合函数的查询必须首先循环访问这些元素，Count、Max、Average和First就属于此类查询。因为查询自己必须使用foreach以便

返回结果，所以这些查询在执行时不使用显式foreach语句。另外还要注意，这些类型的查询返回单个值，而不是IEnumerable集合。

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ查询强制当即执行一
            var nums = new int[7] { 0, 1, 2, 3, 4, 5, 6 };
            var query =
                from num in nums
                where (num % 2) == 0
                select num;
            var numCount = query.Count();
            Console.WriteLine($"NumCount={numCount}");
            Console.Read();
            #endregion
        }
    }
View Code
    运行结果以下：

    若要强制当即执行任意查询并缓存其结果，能够调用ToList<TSource>或ToArray<TSource>方法。

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ查询强制当即执行二
            var nums = new int[7] { 0, 1, 2, 3, 4, 5, 6 };

            var query2 =
               (from num in nums
                where (num % 2) == 0
                select num).ToList();

            var query3 =
                (from num in nums
                 where (num % 2) == 0
                 select num).ToArray();

            Console.WriteLine($"NumCount={query2.Count}");
            Console.WriteLine($"NumCount={query3.Length}");
            Console.Read();
            #endregion
        }
    }
View Code

    运行结果以下：

    2、基本 LINQ 查询操做

    2.1 获取数据源：from

    在LINQ查询中，第一步是指定数据源。像在大多数编程语言中同样，必须先声明变量，才能使用它。在LINQ查询中，最早使用from子句的目的是引入数据

源和范围变量。

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ to SQL
            var db = new SampleDataContext();

            //query是IEnumerable<Cutsomer>类型
            //数据源(db.customers)和范围变量(cust)
            var query =
                from cust in db.Customers
                where cust.City == "London"
                select cust;

            foreach (var item in query)
            {
                Console.WriteLine($"CustomerID={item.CustomerID}");
            }
            Console.Read();
            #endregion
        }
    }
View Code

    范围变量相似于foreach循环中的迭代变量，但在查询表达式中，实际上不发生迭代。执行查询时，范围变量将用做对customers中的每一个后续元素的引用。

由于编译器能够推断cust的类型，因此您没必要显式指定此类型。

    2.2 筛选：where

    也许最经常使用的查询操做是应用布尔表达式形式的筛选器，此筛选器使查询只返回那些表达式结果为true的元素。使用where子句生成结果，实际上，筛选器

指定从源序列中排除哪些元素。

    您可使用熟悉的C#逻辑AND(&&)和OR(||)运算符来根据须要在where子句中应用任意数量的筛选表达式。

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 筛选：where
            var db = new SampleDataContext();

            var query1 =
                from cust in db.Customers
                where cust.City == "London" && cust.CustomerID == "AROUT"
                select cust;
            var query2 =
                from cust in db.Customers
                where cust.City == "London" || cust.City == "Paris"
                select cust;

            foreach (var item in query1)
            {
                Console.WriteLine($"query1->City={item.City},CustomerID={item.CustomerID}");
            }
            foreach (var item in query2)
            {
                Console.WriteLine($"query2->City={item.City},CustomerID={item.CustomerID}");
            }
            Console.Read();
            #endregion
        }
    }
View Code

    运行结果以下：

    2.3 排序：orderby

    一般能够很方便地将返回的数据进行排序。orderby子句将使返回的序列中的元素按照被排序的类型的默认比较器进行排序。

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 排序：orderby
            var db = new SampleDataContext();
            var query =
                from cust in db.Customers
                where cust.City == "London"
                orderby cust.CustomerID
                select cust;
            foreach (var item in query)
            {
                Console.WriteLine($"CustomerID={item.CustomerID}");
            }
            Console.Read();
            #endregion
        }
    }
View Code

    运行结果以下：

    2.4 分组：group

    使用group子句，您能够按指定的键分组结果。

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 分组一：group
            var db = new SampleDataContext();
            var query =
                from cust in db.Customers
                where cust.City == "London" || cust.City == "Paris"
                group cust by cust.City;
            foreach (var group in query)
            {
                Console.WriteLine(group.Key);
                foreach (var cust in group)
                {
                    Console.WriteLine($"City={cust.City},CustomerID={cust.CustomerID}");
                }
            }
            Console.Read();
            #endregion
        }
    }
View Code

    运行结果以下：

    在本例中，cust.City是键。

    在使用group子句结束查询时，结果采用列表的列表形式。列表中的每一个元素是一个具备Key成员及根据该键分组的元素列表的对象。在循环访问生成组

序列的查询时，您必须使用嵌套的foreach循环。外部循环用于循环访问每一个组，内部循环用于循环访问每一个组的成员。  

    若是您必须引用组操做的结果，可使用into关键字来建立可进一步查询的标识符。

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 分组二：group
            var db = new SampleDataContext();
            var query =
                from cust in db.Customers
                where cust.City == "London" || cust.City == "Paris"
                group cust by cust.City into custGroup
                where custGroup.Count() > 2
                orderby custGroup.Key
                select custGroup;
            foreach (var group in query)
            {
                Console.WriteLine(group.Key);
                foreach (var cust in group)
                {
                    Console.WriteLine($"City={cust.City},CustomerID={cust.CustomerID}");
                }
            }
            Console.Read();
            #endregion
        }
    }
View Code

    运行结果以下：

    2.5 联接：join

    联接运算建立数据源中没有显式建模的序列之间的关联。例如，您能够执行联接来查找位于同一地点的全部客户和经销商。在LINQ中，join子句始终针对

对象集合而非直接针对数据库表运行。

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 联接：join
            var db = new SampleDataContext();
            var qurey =
                from order in db.Orders
                join cust in db.Customers on order.CustomerID equals cust.CustomerID
                select new { order.OrderID, order.CustomerID, cust.ContactName };
            foreach (var item in qurey.Take(5))
            {
                Console.WriteLine($"OrderID={item.OrderID},CustomerID={item.CustomerID},ContactName={item.ContactName}");
            }
            Console.Read();
            #endregion
        }
    }
View Code

    运行结果以下：

    2.6 选择（投影）：select

    select子句生成查询结果并指定每一个返回的元素的“形状”或类型。

    例如，您能够指定结果包含的是整个Customer对象、仅一个成员、成员的子集或者某个基于计算或新对象建立的彻底不一样的结果类型。当select子句生成除源

元素副本之外的内容时，该操做称为“投影”。

    3、使用 LINQ 进行数据转换

    语言集成查询 (LINQ) 不可是检索数据的利器，并且仍是一个功能强大的数据转换工具。经过使用LINQ查询，您能够将源序列用做输入，并采用多种方式修改

它以建立新的输出序列。您能够经过排序及分组来修改该序列，而没必要修改元素自己。可是，LINQ 查询的最强大的功能是可以建立新类型。这一功能在select子

句中实现。

    3.1 将多个输入联接到一个输出序列

    /// <summary>
    /// 学生类
    /// </summary>
    class Student
    {
        public string Name { get; set; }

        public int Age { get; set; }

        public string City { get; set; }

        public List<int> Scores { get; set; }
    }

    /// <summary>
    /// 教师类
    /// </summary>
    class Teacher
    {
        public string Name { get; set; }

        public int Age { get; set; }

        public string City { get; set; }
    }      
    
    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 将多个输入联接到一个输出序列
            //建立第一个数据源
            var students = new List<Student>()
            {
                new Student()
                {
                    Age = 19,
                    City = "广州",
                    Name = "小A",
                    Scores = new List<int>(){85,88,83,97}
                },
                new Student()
                {
                    Age = 19,
                    City = "深圳",
                    Name = "小B",
                    Scores = new List<int>(){86,80,85,92}
                }
            };

            //建立第二个数据源
            var teachers = new List<Teacher>()
            {
                new Teacher()
                {
                    Age = 30,
                    City = "广州",
                    Name = "张A"
                },
                new Teacher()
                {
                    Age = 31,
                    City = "广州",
                    Name = "李A"
                }
            };

            //建立查询
            var query = 
                (
                    from student in students
                    where student.City == "广州"
                    select student.Name
                ).Concat
                (
                    from teacher in teachers
                    where teacher.City == "广州"
                    select teacher.Name
                );

            //执行查询
            foreach (var person in query)
            {
                Console.WriteLine(person);
            }

            Console.Read();
            #endregion
        }
    }
View Code

    运行结果以下：

    3.2 选择各个源元素的子集

    1. 若要只选择源元素的一个成员，请使用点运算。

var query = 
    from cust in db.Customers
    select cust.City;

    2. 若要建立包含源元素的多个属性的元素，可使用具备命名对象或匿名类型的对象初始值设定项。

var query = 
    from cust in db.Customer
    select new { cust.Name, cust.City };

    3.3 将内存中的对象转换为XML

    /// <summary>
    /// 学生类
    /// </summary>
    class Student
    {
        public string Name { get; set; }

        public int Age { get; set; }

        public string City { get; set; }

        public List<int> Scores { get; set; }
    }     
    
    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 将内存中的对象转换为XML
            //建立数据源
            var students = new List<Student>()
            {
                new Student()
                {
                    Age = 19,
                    City = "广州",
                    Name = "小A",
                    Scores = new List<int>(){85,88,83,97}
                },
                new Student()
                {
                    Age = 19,
                    City = "深圳",
                    Name = "小B",
                    Scores = new List<int>(){86,80,85,92}
                }
            };
            //建立查询
            var studentsToXml = new XElement
                (
                    "Root",
                    from student in students
                    let x = $"{student.Scores[0]},{student.Scores[1]},{student.Scores[2]},{student.Scores[3]}"
                    select new XElement
                        (
                            "student",
                            new XElement("Name", student.Name),
                            new XElement("Age", student.Age),
                            new XElement("Scores", x)
                        )
                );

            //执行查询
            Console.WriteLine(studentsToXml);
            Console.Read();
            #endregion
        }
    }
View Code

    运行结果以下：

    3.4 对源元素执行操做

    输出序列可能不包含源序列的任何元素或元素属性，它多是经过将源元素用做输入参数计算出的值的序列。

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 对源元素执行操做
            //数据源
            double[] radius = { 1, 2, 3 };
            //建立查询
            var query =
                from radiu in radius
                select $"{3.14 * radiu * radiu}";
            //执行查询
            foreach (var item in query)
            {
                Console.WriteLine(item);
            }
            Console.Read();
            #endregion
        }
    }
View Code

    运行结果以下：

    4、LINQ 查询操做的类型关系

    LINQ 查询操做在数据源、查询自己及查询执行中是强类型的。查询中变量的类型必须与数据源中元素的类型和foreach语句中迭代变量的类型兼容。强类型可

以保证在编译时捕获类型错误，以便及时改正。

    4.1 不转换源数据的查询

    下图演示不对数据执行转换的LINQ to OBJECT查询操做。源包含一个字符串序列，查询输出也是一个字符串序列。

 

    ①数据源的类型参数决定范围变量的类型。

    ②select语句返回Name属性，而非完整的Customer对象。由于Name是一个字符串，因此custNameQuery的类型参数是string，而非Customer。

    ③由于custNameQuery是一个字符串序列，因此foreach循环的迭代变量也必须是string。

    4.2 转换源数据的查询

    下图演示对数据执行简单转换的LINQ to SQL查询操做。查询将一个Customer对象序列用做输入，并只选择结果中的Name属性。由于Name是一个字符串，

因此查询生成一个字符串序列做为输出。

    ①数据源的类型参数决定范围变量的类型。

    ②select语句返回Name属性，而非完整的Customer对象。由于Name是一个字符串，因此custNameQuery的类型参数是string，而非Customer。  

    ③由于custNameQuery是一个字符串序列，因此foreach循环的迭代变量也必须是string。

    下图演示另外一种转换。select 语句返回只捕获原始Customer对象的两个成员的匿名类型。

    ①数据源的类型参数始终为查询中的范围变量的类型。

    ②由于select语句生成匿名类型，因此必须使用var隐式类型化查询变量。

    ③由于查询变量的类型是隐式的，因此foreach循环中的迭代变量也必须是隐式的。

    4.3 让编译器推断类型信息

    您也可使用关键字var，可用于查询操做中的任何局部变量。可是，编译器为查询操做中的各个变量提供强类型。

    5、LINQ 中的查询语法和方法语法

    咱们编写的LINQ查询语法，在编译代码时，CLR会将查询语法转换为方法语法。这些方法调用标准查询运算符的名称相似Where、Select、GroupBy、Join、

Max和Average，咱们也是能够直接使用这些方法语法的。

    查询语法和方法语法语义相同，可是，许多人员发现查询语法更简单、更易于阅读。某些查询必须表示为方法调用。例如，必须使用方法调用表示检索元素

的数量与指定的条件的查询，还必须使用方法须要检索元素的最大值在源序列的查询。System.Linq命名空间中的标准查询运算符的参考文档一般使用方法语法。

    5.1 标准查询运算符扩展方法

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 标准查询运算符扩展方法
            var nums = new int[4] { 1, 2, 3, 4 };

            //建立查询表达式
            var query1 = 
                from num in nums
                where num % 2 == 0
                orderby num descending
                select num;

            Console.WriteLine("Query1's result:");
            foreach (var num in query1)
            {
                Console.WriteLine(num);
            }

            //使用方法进行查询
            var query2 = nums.Where(num => num % 2 == 0).OrderByDescending(num => num);

            Console.WriteLine("Query2's result:");
            foreach (var num in query2)
            {
                Console.WriteLine(num);
            }

            Console.Read();
            #endregion
        }
    }
View Code

    运行结果以下：

    两个示例的输出是相同的。您能够看到两种形式的查询变量的类型是相同的：IEnumerable<T>。

    若要了解基于方法的查询，让咱们进一步地分析它。注意，在表达式的右侧，where子句如今表示为对numbers对象的实例方法，在您从新调用该对象时其类型

为IEnumerable<int>。若是您熟悉泛型 IEnumerable<T> 接口，那么您就会了解，它不具备Where方法。可是，若是您在Visual Studio IDE中调用IntelliSense完成

列表，那么您不只将看到Where方法，并且还会看到许多其余方法，如Select、SelectMany、Join 和Orderby。

    下面是全部标准查询运算符：

    尽管看起来IEnumerable<T>彷佛已被从新定义以包括这些附加方法，但事实上并不是如此，这些标准查询运算符都是做为“扩展方法”实现的。

    5.2 Lambda 表达式

    在前面的示例中，通知该条件表达式 (num % 2 == 0) 是做为内联参数。Where方法：Where (num => num % 2 == 0) 此内联表达式称为lambda表达式。将代码

编写为匿名方法或泛型委托或表达式树是一种便捷的方法，不然编写起来就要麻烦得多。=>是lambda运算符，可读为“goes to”。运算符左侧的num是输入变量，

与查询表达式中的num相对应。编译器可推断num的类型，由于它了解numbers是泛型IEnumerable<T>类型。Lambda表达式与查询语法中的表达式或任何其余C#

表达式或语句中的表达式相同，它能够包括方法调用和其余复杂逻辑，“返回值”就是表达式结果。

    5.3 查询的组合性

    在上面的代码示例中，请注意OrderBy方法是经过在对Where的调用中使用点运算符来调用的。Where生成筛选序列，而后Orderby经过对该序列排序来对它进行

操做。由于查询会返回IEnumerable，因此您可经过将方法调用连接在一块儿，在方法语法中将这些查询组合起来。这就是在您经过使用查询语法编写查询时编译器在

后台所执行的操做，而且因为查询变量不存储查询的结果，所以您能够随时修改它或将它用做新查询的基础，即便在执行它后。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程