Linq 简明教程

一个简单的实例

   static void Main(string[] args)
        {
            string[] names = { "Alonso", "Zheng", "Jones", "Small",
"Ruiz", "Hsieh", "Jorgenson", "Ilyich", "Samba", "Fatimah" };

            var queryResults = from a in names
                               where a.StartsWith("J")
                               select a;
            
            Console.WriteLine("Names beginning with S:");
            
            foreach (var item in queryResults)
            {
                Console.WriteLine(item);
            }
           
            Console.ReadLine();
        }   

输出结果：

说明:   

该语句包括4 个部分：以var 开头的结果变量声明，使用查询表达式给该结果变量赋值，查询表达式包含from 子句、where 子句和select 子句

• var 是C#中的一个新关键字，用于声明一般的变量类型，特别适合于包含LINQ查询的结果。var 关键字告诉C#编译器，根据查询推断结果的类型。这样，就不必提前声明从LINQ
  查询返回的对象类型了——编译器会推断出该类型。如果查询返回多个条目，该变量就是查询数据源中的一个对象集合(在技术上它并不是一个集合，只是看起来像是集合而已)
• 本例中的数据源是前面声明的字符串数组names。变量a 只是数据源中某一元素的代表，类似于foreach 语句后面的变量名。指定from 子句，就可以只查找集合的一个子集，而不用迭代所有的元素。
• 可以在where 子句中指定能应用于数据源中各元素的任意布尔(true 或false)表达式。实际上，where 子句是可选的，甚至可以忽略，但在大多数情况下，都要指定where 条件，把结果限制为我们需要的数据。where 子句称为LINQ 中的限制运算符， 因为它限制了查询的结果。
• select 子句是必须的，因为必须指定结果集中有哪些元素。这个结果集并不是很有趣，因为在结果集的每个元素中都只有一项name。如果结果集中有比较复杂的对象，使用select 子句的有效性就
  比较明显，不过在们还是先完成这个示例。
  
  

除了查询语句，还有一种是 方法语句：

 var queryResults = names.Where(n => n.StartsWith("S"));

得到的效果和查询语句一样

说明：

C#编译器把Lambda 表达式n => n.StartsWith("S"))编译为一个匿名方法，Where()在names 数组的每个元素上执行这个方法。如果Lambda 表达式给某个元素返回true，该元素就包含在Where()返回的结果集中。

 

 为查询结果排序： 谁用 orderby 语句

   var queryResults =
                from n in names
                where n.StartsWith("S")
                orderby n 
                select n;

结果：

注意: 与where 子句一样，orderby 子句也是可选的

        orderby 子句默认为升序(A 到Z)，但可以添加descending 关键字，以便指定降序(Z 到A)

orderby a descending

方法语法 排序

 var queryResults = names.OrderBy(n => n).Where(n => n.StartsWith("J"));

说明：

需要把一个Lambda 表达式传送给OrderBy()方法，告诉它用于排序的函数是什么。在们传送了最简单的Lambda 表达式n => n，因为只需要按照元素本身排序。

 

逆序排序：使用 OrderByDescending()

 var queryResults = names.OrderByDescending(n => n).Where(n => n.StartsWith("S"));

查询复杂的对象：

 

namespace LinqTest
{
    class Customer
    {
        public string ID { get; set; }
        public string City { get; set; }
        public string Province { get; set; }
        public decimal Sales { get; set; }

        //重写 ToString() 方法
        public override string ToString()
        {
            return "ID: " + ID + " City: " + City + " Province: " + Province + " Sales: " + Sales;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            List<Customer> customers = new List<Customer>(){
                new Customer{ID="A",City="北京",Province="北京",Sales=9999},
                new Customer{ID="B",City="成都",Province="四川",Sales=6666},
                new Customer{ID="C",City="乐山",Province="四川",Sales=3333},
                new Customer{ID="D",City="绵阳",Province="四川",Sales=2222},
                new Customer{ID="E",City="杭州",Province="浙江",Sales=5555},
                new Customer{ID="F",City="绍兴",Province="浙江",Sales=3333},
                new Customer{ID="G",City="宁波",Province="浙江",Sales=7777},
                new Customer{ID="F",City="舟山",Province="浙江",Sales=8888},
            };
            var queryResults = from c in customers
                               where c.Province == "四川"  //选取省份为四川的
                               select c;
            //输出结果
            foreach (var item in queryResults)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();      
        }    
    }
}

结果：

说明：

这个查询应很眼熟，在其他示例中使用的也是from ... where ... select 查询，只是结果列表中的每一项都是一个完整对象(Customer)，而不是简单的string 或int

投影：在查询中创建新对象 

　　　　　　　　　　　　　　　　　　var queryResults = from c in customers
                               where c.Province == "四川"  //选取省份为四川的
                               select c.City;  //只选取 Customer类中的City属性

结果：

 若要提取对象中的多个属性则可：

1　　　　　　　　　　　　　　　　　　 var queryResults = from c in customers
                               where c.Province == "四川"  //选取省份为四川的
                               select new { c.City, c.Province };  //选取多个值的时候需要用  select new {  } 

结果：

 说明：

 这里在select 子句中直接使用C#匿名类型创建语法，创建一个未命名的对象类型，它带有City、Province属性。select 子句创建了新对象。这样，只会复制这2个属性，完成处理查询的不同阶段。

 

投影: 方法语法

 

var queryResults = customers.Where(c => c.Province == "四川").Select(c => new { c.City, c.Province });

结果和上面一样

  多级排序：

查询语法：

处理了带多个属性的对象后，就要考虑另一种情形了：按一个字段给查询结果排序是不够的，

需要查询管理，先安装 省份 排序，再按照 城市 排序

 

    　　　　var queryResults = from c in customers
                               orderby c.Province, c.City
                               select c;

结果：  先安装 省份 排序，再按照 城市 排序

 多级排序之　方法语法： 使用 ThenBy 语句

 var queryResults = customers.OrderBy(c => c.Province)
                .ThenBy(c => c.City)
                .Select(c => c);

结果同上

分组查询：

 若想查出每个省份的总销售额，则使用分组查询

1　　　　　　 var queryResults = from c in customers  
                               group c by c.Province into cg
                               select new { TotalSales = cg.Sum(c => c.Sales), Province = cg.Key };

            //对新得到的结果集在进行 选取相关值
            var orderedResults = from t in queryResults   //t 只是个参数而已，随便命名
                                 orderby t.TotalSales descending
                                 select t;

结果：

说明：

分组查询中的数据通过一个键(key)字段来分组，每个组中的所有成员都共享这个字段值。在这个例子中，键字段是　c.Province

要计算每个组的总和，应生成一个新的结果集 cg

在 select 子句中，投影了一个新的匿名类型，其属性是总销售量(通过引用cg 结果集来计算)和组的键值，后者是用特殊的组Key 来引用的 

Join语句：

namespace LinqTest
{
    class Customer
    {
        public string ID { get; set; }
        public string City { get; set; }
        public string Province { get; set; }
        public decimal Sales { get; set; }

        //重写 ToString() 方法
        public override string ToString()
        {
            return "ID: " + ID + " City: " + City + " Province: " + Province + " Sales: " + Sales;
        }
    }

    class Order
    {
        public string ID { get; set; }
        public decimal Amount { get; set; } 
    }

    class Program
    {
        static void Main(string[] args)
        {
            List<Customer> customers = new List<Customer>(){
                new Customer{ID="A",City="北京",Province="北京",Sales=9999},
                new Customer{ID="B",City="成都",Province="四川",Sales=6666},
                new Customer{ID="C",City="乐山",Province="四川",Sales=3333},
                new Customer{ID="D",City="绵阳",Province="四川",Sales=2222},
                new Customer{ID="E",City="杭州",Province="浙江",Sales=5555},
                new Customer{ID="F",City="绍兴",Province="浙江",Sales=3333},
                new Customer{ID="G",City="宁波",Province="浙江",Sales=7777},
                new Customer{ID="F",City="舟山",Province="浙江",Sales=8888},
            };

            List<Order> orders = new List<Order>()
            {
                new Order{ID="A",Amount = 1111},
                new Order{ID="B",Amount=2222},
                new Order{ID="C",Amount = 3333},
            };


            var queryResults = from c in customers
                               join o in orders on c.ID equals o.ID      //相当于 SQL中的 join 语句
                               select new { c.ID, c.City, SalesBefore = c.Sales, NewOrder = o.Amount, SalesAfter = c.Sales + o.Amount };
            //创建新对象  包含属性 ID City SalesBefore, NewOrder ,SalesAfter 几个属性


            foreach (var item in queryResults)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();      
        }    
    }
}

结果：

　　　　　　　　var queryResults = from c in customers
                               join o in orders on c.ID equals o.ID      //相当于 SQL中的 join 语句
                               select new { c.ID, c.City, SalesBefore = c.Sales, NewOrder = o.Amount, SalesAfter = c.Sales + o.Amount };
            //创建新对象  包含属性 ID City SalesBefore, NewOrder ,SalesAfter 几个属性

说明：

查询使用join 关键字通过Customer 类和Order 类的ID 字段，把每个顾客与其对应的订单连接起来

equals 关键字指定另一个集合中的对应字段。查询结果仅包含两个集中ID 字段值相同的对象数据。

select 语句投影了一个带指定属性的新数据类型，因此可以清楚地看到最初的总销售量、新订单和最终的新总销售量：