LINQ(集成化查询)

      LINQ可以对数组、集合等数据结构进行查询、筛选、排序等操作；也可以用于与数据库交互；也支持对XML的操作，使用LINQ技术可以动态创建、筛选和修改XML数据和直接操作XML文件。

一). LINQ基本语法：

      (1)所有的LINQ查询表达式都是以from....in....开头；

      (2)以select或group子句结束。以select子句结束表示从数据源序列筛选出元素；以group子句结束表示将从数据源序列中筛选出来的元素进行分组，并把每个分组放进查询结果集中。

例如：var result=from str in list select str;

         var result from str in list group s by str[0];   

二).延迟执行与强制立即执行

   先看以下代码：var result=from str in list select str;当执行上述代码时，LINQ查询实际上并未执行，而是仅仅把用于查询的“命令”存放在result变量中，只到执行到遍历访问代码时才会执行查询：foreach(var a in result){。。。。。}，这就是延迟执行。当然，可以调用Count，ToList，ToArray等方法来时查询立即执行，即使LINQ查询强行立即执行。

三).筛选、排序、分组

(1)在查询语句中，用where子句来设定筛选条件（一个或多个条件），如果where子句后面条件为真，则符合条件；若为假，则不符合条件。

例如：var a=from b in c where b>10 select b;

(2)对查询结果重新排序可以用orderby子句，默认情况下按升序排序，如果要进行降序排序，就必须在orderby子句后加上descending关键字。

例如：var a=from b in c orderby b select b;

(3)对数据进行分组要有分组依据，因此group一般与by关键字连用，格式如下：group <要进行分组的元素>by<分组依据>

如果要对分组的数据进行操作，可以在查询语句中储存个分组的数据，即在分组语句后面接上into关键字。如：group emp by emp.Department into eg;数据分组后会将每个分量都存入eg变量中，随后可以用select子句把存放在eg中的分组选择进行结果中。如下：group emp by emp.Department into eg select eg;这时候查询结果中的每个元素都是IGrouping<TKey,TElement>类型的对象，IGrouping<TKey,TElement>带了2个类型参数，TKey表示分组依据(Key)的类型，TElement表示每个分组中元素的类型，由于IGrouping接口继承自IEnumerable<out T>接口，因此，只要使用foreach循环就可以访问分组中的元素。

            // 示例数据源
            string[] arr = { "table", "use", "up", "take", "turn", "reset", "remove", "we", "wave", "work", "word" };

            // 查询数据源中的所有元素
            // 并以首字母作为分组依据
            var res = from s in arr
                      group s by s.ToUpper()[0];
            // 输出查询结果
            Console.WriteLine("共有{0}个分组。", res.Count());
            foreach (IGrouping<char, string> item in res)
            {
                Console.WriteLine("--------- {0} --------", item.Key);
                // 取出该分组中的元素
                foreach (string str in item)
                {
                    Console.WriteLine("  {0}", str);
                }
                Console.WriteLine();
            }

下面在看一例：

public class Student
    {
        /// <summary>
        /// 学员ID
        /// </summary>
        public uint StuID { get; set; }
        /// <summary>
        /// 学员姓名
        /// </summary>
        public string StuName { get; set; }
        /// <summary>
        /// 课程
        /// </summary>
        public string Course { get; set; }
    }

            Student[] students =
            {
                new Student { StuID = 1, StuName = "小陈", Course = "C++基础" },
                new Student { StuID = 2, StuName = "小林", Course = "VB入门" },
                new Student { StuID = 3, StuName = "小邓", Course = "C++基础" },
                new Student { StuID = 4, StuName = "小李", Course = "C#客户端开发" },
                new Student { StuID = 5, StuName = "小唐", Course = "C++基础" },
                new Student { StuID = 6, StuName = "小周", Course = "VB入门" },
                new Student { StuID = 7, StuName = "小张", Course = "VB入门" },
                new Student { StuID = 8, StuName = "小吴", Course = "C#客户端开发" },
                new Student { StuID = 9, StuName = "小孙", Course = "C++基础" },
                new Student { StuID = 10, StuName = "小孟", Course = "C#客户端开发" }
            };
            // 筛选出学号大于5的学员
            // 并按课程进行分组
            // 学号按降序排列
            var res = from s in students
                  orderby s.StuID descending
                  where s.StuID > 5
                  group s by s.Course into g
                  select g;
            foreach (var g in res)
            {
                Console.WriteLine("----- {0} -----", g.Key);
                foreach (Student stu in g)
                {
                    Console.WriteLine("学号：{0}，姓名：{1}，课程：{2}", stu.StuID, stu.StuName, stu.Course);
                }
                Console.WriteLine();
            }

四).复杂查询

(1)动态创建类型

在比较复杂的查询中，查询结果通常会生成一个新的类型，以使其内部包含来自多个数据序列的属性。许多时候，这些新类型并不是固定的，不同的查询需求会产生不同的结果，如果为每种查询结果都去定义相应的类，那有可能变得很复杂，面对这种情况，使用动态类型是较理想的选择。动态类型无需事先去定义类，即可根据代码上下文的需要动态地去创建新类型，实现方法是运用new运算符，创建的新类型并没有确切的名称，是由编译器自动分配的，因此在声明量时应使用var关键字，由编译器自动去识别其类型。

例如：

            var a = new
            {
                b = "cajj",
                c = 123
            };
            Console.WriteLine("{0}    {1}", a.b, a.c);

也可以使用dynamic关键字来声明用于引用匿名类型的变量。使用dynamic声明的变量属于动态类型，在编译阶段不进行解析，只在运行时动态解析。

例如：

dynamic b = new
            {
                Name = "Java",
                Age = 18,
                Birth = new DateTime(1997, 07, 06)
            };
            Console.WriteLine("Name={0}   Age={1}   Birth={2:yyyy-M-d}", b.Name, b.Age, b.Birth);

(2)联合查询

联合查询主要通过jion关键字来完成的。所谓的联合查询，可以理解为联合多个数据序列进行查询，并从中返回查询结果。查询结果中的数据可能来自于多个数据序列。多个数据序列要进行联合，需要提供一个联合条件才能使多个序列完成正确的联合，所以，jion关键字后面紧跟着on关键字，并通过equals关键字来判断联合条件是否成立。

代码如下：

    /// <summary>
    /// 图书分类信息
    /// </summary>
    public class Category
    {
        /// <summary>
        /// 分别ID
        /// </summary>
        public int catID { get; set; }
        /// <summary>
        /// 分类名
        /// </summary>
        public string catName { get; set; }
    }

    /// <summary>
    /// 图书信息
    /// </summary>
    public class BookInfo
    {
        /// <summary>
        /// 图书ID
        /// </summary>
        public int BookID { get; set; }
        /// <summary>
        /// 书名
        /// </summary>
        public string BookName { get; set; }
        /// <summary>
        /// 图书所属分类的ID
        /// </summary>
        public int CateID { get; set; }
    }

            // 图书分类示例数据
            List<Category> bookCategs = new List<Category>
            {
                new Category { catID = 201, catName = "文学类" },
                new Category { catID = 202, catName = "经济管理类" },
                new Category { catID = 203, catName = "机械工程类" },
                new Category { catID = 204, catName = "法律基础类" }
            };

            // 图书信息示例数据
            List<BookInfo> books = new List<BookInfo>
            {
                new BookInfo { BookID = 1, BookName = "图书01", CateID = 202 },
                new BookInfo { BookID = 2, BookName = "图书02",CateID = 204 },
                new BookInfo { BookID = 3, BookName = "图书03", CateID = 201 },
                new BookInfo { BookID = 4, BookName = "图书04", CateID = 202 },
                new BookInfo { BookID = 5, BookName = "图书05",CateID = 204 },
                new BookInfo { BookID = 6, BookName = "图书06", CateID = 204 },
                new BookInfo { BookID = 7, BookName = "图书07", CateID = 203 },
                new BookInfo { BookID = 8, BookName = "图书08",CateID = 202 },
                new BookInfo { BookID = 9, BookName = "图书09", CateID = 203 },
                new BookInfo { BookID = 10, BookName = "图书10", CateID = 202 },
                new BookInfo { BookID = 11, BookName = "图书11", CateID = 201 },
                new BookInfo { BookID = 12, BookName = "图书12", CateID = 203 },
                new BookInfo { BookID = 13, BookName = "图书13", CateID = 201 },
                new BookInfo { BookID = 14, BookName = "图书14", CateID = 204 },
                new BookInfo { BookID = 15, BookName = "图书15", CateID = 203 },
                new BookInfo { BookID = 16, BookName = "图书16", CateID = 202 },
            };

接下来，联合books和bookCategs两个数据序列，代码如下：

            // 联合查询，并产生新的类型
            var qryres = from b in books
                         join c in bookCategs on b.CateID equals c.catID
                         select new
                         {
                             b.BookName,
                             c.catName
                         };
            // 输出结果
            foreach (var bitem in qryres)
            {
                Console.WriteLine("图书名：{0}，所属分类：{1}", bitem.BookName, bitem.catName);
            }

上述代码，select子句使用new运算符动态创建匿名类型，并使用BookInfo对象的BookName属性和Category对象的catName属性作为新类型的属性，也就是说，创建的匿名类型具有BookName和catName两个属性，当然，也可以为动态创建的匿名类型使用自己命名的属性名，代码如下：

            var qryres2 =
                from bk in books
                join bc in bookCategs on bk.CateID equals bc.catID
                select new
                    {
                        Book_ID = bk.BookID,
                        Book_Name = bk.BookName,
                        Book_Cate = bc.catName
                    };
            // 输出结果
            foreach (var bk in qryres2)
            {
                Console.WriteLine("图书ID：{0}，图书名：{1}，所属分类：{2}", bk.Book_ID, bk.Book_Name, bk.Book_Cate);
            }

在上面的例子中，与每个BookInfo对象实例的CateID属性相对应的Category对象都能在bookCategs列表中找到，这种的联合查询称为”内部联合“。下面，就考虑另一种情况，即当序列A与序列B进行联合查询时，在序列B中找不到与序列A的项匹配的元素。

代码如下：

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

namespace My
{

    #region 定义类型
    /// <summary>
    /// 专辑信息
    /// </summary>
    public class Album
    {
        /// <summary>
        /// 专辑名称
        /// </summary>
        public string Title { get; set; }
        /// <summary>
        /// 发行年份
        /// </summary>
        public int Year { get; set; }
        /// <summary>
        /// 专辑描述
        /// </summary>
        public string Description { get; set; }
    }

    /// <summary>
    /// 曲目信息
    /// </summary>
    public class Track
    {
        /// <summary>
        /// 曲目名称
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 艺术家名字
        /// </summary>
        public string Artist { get; set; }
        /// <summary>
        /// 所属专辑
        /// </summary>
        public Album AlbumOf { get; set; }
    }
    #endregion

    class Program
    {
        static void Main(string[] args)
        {
            // 专辑列表
            Album album1 = new Album { Title = "专辑 1", Year = 2003, Description = "这是第一张专辑。" };
            Album album2 = new Album { Title = "专辑 2", Year = 2009, Description = "这是第二张专辑。" };
            List<Album> albums = new List<Album> { album1, album2 };

            // 曲目列表
            Track track1 = new Track { Name = "曲目 1", Artist = "艺术家 1", AlbumOf = album1 };
            Track track2 = new Track { Name = "曲目 2", Artist = "艺术家 2", AlbumOf = album2 };
            Track track3 = new Track { Name = "曲目 3", Artist = "艺术家 3", AlbumOf = album2 };
            Track track4 = new Track { Name = "曲目 4", Artist = "艺术家 4", AlbumOf = album1 };
            Track track5 = new Track { Name = "曲目 5", Artist = "艺术家 5", AlbumOf = album2 };
            Track track6 = new Track { Name = "曲目 6", Artist = "艺术家 6", AlbumOf = null };
            List<Track> tracks = new List<Track> { track1, track2, track3, track4, track5, track6 };

            // 开始查询
            var res1 = from t in tracks
                       join a in albums on t.AlbumOf equals a into g1
                       from a1 in g1.DefaultIfEmpty()
                       select new
                       {
                           TrackName = t.Name,
                           Artist = t.Artist,
                           AlbumName = a1 == null ? "未知专辑" : a1.Title
                       };

            // 以下代码会发生异常
            //var res1 = from t in tracks
            //           join a in albums on t.AlbumOf equals a into g1
            //           from a1 in g1.DefaultIfEmpty()
            //           select new
            //           {
            //               TrackName = t.Name,
            //               Artist = t.Artist,
            //               AlbumName = a1.Title
            //           };

            // 输出结果
            foreach (var item in res1)
            {
                Console.WriteLine("曲目：{0}，艺术家：{1}，专辑：{2}", item.TrackName, item.Artist, item.AlbumName);
            }

            Console.WriteLine();

            var res2 = from t in tracks
                       join a in albums on t.AlbumOf equals a into g
                       from a2 in g.DefaultIfEmpty(new Album { Title = "<未知>", Year = 0, Description = "<无>" })
                       select new
                           {
                               TrackName = t.Name,
                               Year = a2.Year,
                               Artist = t.Artist,
                               AlbumName = a2.Title,
                               AlbumDesc = a2.Description
                           };
            // 输出结果
            foreach (var item in res2)
            {
                Console.WriteLine("曲目：{0}，年份：{1}，艺术家：{2}，专辑：{3}，专辑描述：{4}", item.TrackName, item.Year, item.Artist, item.AlbumName, item.AlbumDesc);
            }

            Console.Read();
        }
    }
}

(3) 嵌套查询

嵌套查询是指在一个查询内部嵌套这另一个查询，其实嵌套查询是比较简单的，就直接看个例子吧。

代码如下：

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

namespace My
{
    #region 定义类型
    /// <summary>
    /// 商品信息
    /// </summary>
    public class Goods
    {
        /// <summary>
        /// 商品编号
        /// </summary>
        public string GsNo { get; set; }
        /// <summary>
        /// 商品名称
        /// </summary>
        public string GsName { get; set; }
        /// <summary>
        /// 商品单价
        /// </summary>
        public double GsPrice { get; set; }
    }

    /// <summary>
    /// 销售单信息
    /// </summary>
    public class SalesOrder
    {
        /// <summary>
        /// 单据ID
        /// </summary>
        public int OrderID { get; set; }
        /// <summary>
        /// 商品编号
        /// </summary>
        public string GoodsNo { get; set; }
        /// <summary>
        /// 销售时间
        /// </summary>
        public DateTime Time { get; set; }
        /// <summary>
        /// 销售数量
        /// </summary>
        public int Qty { get; set; }
    }
    #endregion

    class Program
    {
        static void Main(string[] args)
        {
            // 商品信息 - 示例数据
            Goods[] goodsArr = 
            {
                new Goods { GsNo = "G-1", GsName = "报纸", GsPrice = 1.50d },
                new Goods { GsNo = "G-2", GsName = "食盐", GsPrice = 3.65d },
                new Goods { GsNo = "G-3", GsName = "火柴", GsPrice = 0.50d },
                new Goods { GsNo = "G-4", GsName = "灯泡", GsPrice = 12.30d },
                new Goods { GsNo = "G-5", GsName = "剪刀", GsPrice = 4.50d }
            };

            // 销售单据 - 示例数据
            SalesOrder[] orders =
            {
                new SalesOrder { OrderID = 1, GoodsNo = goodsArr[0].GsNo, Qty = 3, Time = new DateTime(2014, 1, 2) },
                new SalesOrder { OrderID = 2, GoodsNo = goodsArr[1].GsNo, Qty = 5, Time = new DateTime(2014, 1, 4) },
                new SalesOrder { OrderID = 3, GoodsNo = goodsArr[2].GsNo, Qty = 2, Time = new DateTime(2014, 1, 12) },
                new SalesOrder { OrderID = 4, GoodsNo = goodsArr[3].GsNo, Qty = 6, Time = new DateTime(2014, 1, 20) },
                new SalesOrder { OrderID = 5, GoodsNo = goodsArr[4].GsNo, Qty = 1, Time = new DateTime(2014, 2, 3) },
                new SalesOrder { OrderID = 6, GoodsNo = goodsArr[2].GsNo, Qty = 4, Time = new DateTime(2014, 2, 9) },
                new SalesOrder { OrderID = 7, GoodsNo = goodsArr[1].GsNo, Qty = 8, Time = new DateTime(2014, 3, 13) },
                new SalesOrder { OrderID = 8, GoodsNo = goodsArr[3].GsNo, Qty = 10, Time = new DateTime(2014, 3, 11) },
                new SalesOrder { OrderID = 9, GoodsNo = goodsArr[0].GsNo, Qty = 15, Time = new DateTime(2014, 3, 18) },
                new SalesOrder { OrderID = 10, GoodsNo = goodsArr[0].GsNo, Qty = 7, Time = new DateTime(2014, 2, 22) },
                new SalesOrder { OrderID = 11, GoodsNo = goodsArr[3].GsNo, Qty = 20, Time = new DateTime(2014, 3, 17) },
                new SalesOrder { OrderID = 12, GoodsNo = goodsArr[1].GsNo, Qty = 13, Time = new DateTime(2014, 1, 29) },
                new SalesOrder { OrderID = 13, GoodsNo = goodsArr[2].GsNo, Qty = 8, Time = new DateTime(2014, 2, 9) },
                new SalesOrder { OrderID = 14, GoodsNo = goodsArr[4].GsNo, Qty = 21, Time = new DateTime(2014, 3, 16) },
                new SalesOrder { OrderID = 15, GoodsNo = goodsArr[2].GsNo, Qty = 6, Time = new DateTime(2014, 2, 15) }
            };

            /*
             * 查询并计算出各个商品的
             * 总销售额
             */
            var res = from g in goodsArr
                      let totalQty =
                      /* 以下为嵌套查询 */
                      (from od in orders
                       where od.GoodsNo == g.GsNo
                       select od).Sum(odr => odr.Qty)
                      select new
                          {
                              g.GsNo,
                              g.GsName,
                              /* 计算总销售额 */
                              Total = totalQty * g.GsPrice
                          };

            // 输出查询结果
            foreach (var item in res)
            {
                Console.WriteLine("编号：{0}，商品：{1}，总额：{2:N2}", item.GsNo, item.GsName, item.Total);
            }

            Console.Read();
        }
    }
}

博客写到这，可以看到其实LINQ查询是比较简单的，只要仔细，就不会出错的。。。。