LINQ之Select/Distinct/Count/Sum/Min/Max/Avg(转)

Select/Distinct操作符

说明 ：和SQL命令中的select作用相似但位置不同，查询表达式中的select及所接子句是放在表达式最后并把子句中的变量也就是结果返回回来；延迟。

Select/Distinct操作包括9种形式，分别为简单形式、匿名类型形式、带条件形式、指定类型形式、过滤类型形式、shaped类型形式、嵌套类型形式、LocalMethodCall形式、Distinct形式。

1.简单形式：

var
 q =
  from
 c in
 db.Customers
  select
 c.ContactName;

注意：这个语句只是一个声明或者一个描述，并没有真正把数据取出来，只有当你需要该数据的时候，它才会执行这个语句，这就是延迟加载 (deferred loading)。如果，在声明的时候就返回的结果集是对象的集合。你可以使用ToList() 或ToArray()方法把查询结果先进行保存，然后再对这个集合进行查询。当然延迟加载(deferred loading)可以像拼接SQL语句那样拼接查询语法，再执行它。

2.匿名类型形式：

说明：匿名类型是C# 3.0中新特性。其实质是编译器根据我们自定义自动产生一个匿名的类来帮助我们实现临时变量的储存。匿名类型还依赖于另外一个特性：支持根据 property来创建对象。比如，var d = new { Name = "400电话 " };编译器自动产生一个有property叫做Name的匿名类，然后按这个类型分配内存，并初始化对象。但是var d = new {"400电话 "};是编译不通过的。因为，编译器不知道匿名类中的property的名字。例如string c = "http://www.my400800.cn ";var d = new { c}; 则是可以通过编译的。编译器会创建一个叫做匿名类带有叫c的property。
例如下例：new{c,ContactName,c.Phone};ContactName和Phone都是在映射文件中定义与表中字段相对应的 property。编译器读取数据并创建对象时，会创建一个匿名类，这个类有两个属性，为ContactName和Phone，然后根据数据初始化对象。 另外编译器还可以重命名property的名字。

var
 q =
      from
 c in
 db.Customers
      select
 new
 {c.ContactName, c.Phone};

语句描述：查询顾客的联系人和电话。

var
 q =
      from
 e in
 db.Employees
      select
 new
 {Name = e.FirstName + " "
 + e.LastName, Phone = e.HomePhone};

语句描述：查询职员的姓名和家庭电话

var
 q =
      from
 p in
 db.Products
      select
 new
 {p.ProductID, HalfPrice = p.UnitPrice / 2};

3.带条件形式：

说明：生成SQL语句为：case when condition then else。

var
 q =
      from
 p in
 db.Products
      select
 new
 {p.ProductName, Availability = p.UnitsInStock - p.UnitsOnOrder < 0 ? "Out Of Stock"
: "In Stock"
};

4.指定类型形式：

说明：该形式返回你自定义类型的对象集。

var
 q =
      from
 e in
 db.Employees
      select
 new
 Name
 {FirstName = e.FirstName, LastName = e.LastName};

5.过滤类型形式：

说明：结合where使用，起到过滤作用。

var
 q =
      from
 c in
 db.Customers
      where
 c.City == "London"

      select
 c.ContactName;

6.shaped类型形式：

说明：其select操作使用了匿名对象，而这个匿名对象中，其属性也是个匿名对象。

var
 q =
      from
 c in
 db.Customers
      select
 new
 {
        c.CustomerID,
        CompanyInfo = new
 {c.CompanyName, c.City, c.Country},
        ContactInfo = new
 {c.ContactName, c.ContactTitle}
    };

语句描述：查询顾客的ID和公司信息（公司名称，城市，国家）以及联系信息（联系人和职位）。

7.嵌套类型形式：

说明：返回的对象集中的每个对象DiscountedProducts属性中，又包含一个集合。也就是每个对象也是一个集合类。

var
 q =
      from
 o in
 db.Orders
      select
 new
 {
        o.OrderID,
        DiscountedProducts =
          from
 od in
 o.OrderDetails
          where
 od.Discount > 0.0
          select
 od,
        FreeShippingDiscount = o.Freight
    };

8.LocalMethodCall形式：

var
 q = from
 c in
 db.Customers
      where
 c.Country == "UK"
 || c.Country == "USA"

      select
 new
 { c.CustomerID, c.CompanyName, Phone = c.Phone, InternationalPhone =

PhoneNumberConverter(c.Country, c.Phone) };

 

XDocument
 doc = new
 XDocument
(
      new
 XElement
("Customers"
, from
 c in
 db.Customers
                where
 c.Country == "UK"
 || c.Country == "USA"

                select
 (new
 XElement
("Customer"
,
                  new
 XAttribute
("CustomerID"
, c.CustomerID),
                  new
 XAttribute
("CompanyName"
, c.CompanyName),
                  new
 XAttribute
("InterationalPhone"
, PhoneNumberConverter(c.Country, c.Phone))
                  ))));

9.Distinct形式：

说明：筛选字段中不相同的值。用于查询不重复的结果集。生成SQL语句为：SELECT DISTINCT [City] FROM [Customers]

var
 q = (
      from
 c in
 db.Customers
      select
 c.City )
      .Distinct();

语句描述：查询顾客覆盖的国家。

Count/Sum/Min/Max/Avg操作符

 

适用场景 ：统计数据吧，比如统计一些数据的个数，求和，最小值，最大值，平均数。

Count

说明 ：返回集合中的元素个数，返回INT类型；不延迟。生成SQL语句为：SELECT COUNT(*) FROM

1.简单形式：

var
 q = db.Customers.Count();

2.带条件形式：

var
 q = db.Products.Count(p => !p.Discontinued);

LongCount

说明 ：返回集合中的元素个数，返回LONG类型；不延迟。对于元素个数较多的集合可视情况可以选用LongCount来统计元素个数，它返回long类型，比较精确。生成SQL语句为：SELECT COUNT_BIG(*) FROM

var
 q = db.Customers.LongCount();

Sum

说明 ：返回集合中数值类型元素之和，集合应为INT类型集合；不延迟。生成SQL语句为：SELECT SUM(…) FROM

1.简单形式：

var
 q = db.Orders.Select(o => o.Freight).Sum();

2.映射形式：

var
 q = db.Products.Sum(p => p.UnitsOnOrder);

Min

说明 ：返回集合中元素的最小值；不延迟。生成SQL语句为：SELECT MIN(…) FROM

1.简单形式：

var
 q = db.Products.Select(p => p.UnitPrice).Min();

2.映射形式：

var
 q = db.Orders.Min(o => o.Freight);

3.原理：

var
 categories =
      from
 p in
 db.Products
      group
 p by
 p.CategoryID into
 g
      select
 new
 {
           CategoryID = g.Key,
           CheapestProducts =
               from
 p2 in
 g
               where
 p2.UnitPrice == g.Min(p3 => p3.UnitPrice)
               select
 p2
      };

 

 

Max

说明 ：返回集合中元素的最大值；不延迟。生成SQL语句为：SELECT MAX(…) FROM

1.简单形式：

var
 q = db.Employees.Select(e => e.HireDate).Max();

2.映射形式：

var
 q = db.Products.Max(p => p.UnitsInStock);

3.原理：

var
 categories =
      from
 p in
 db.Products
      group
 p by
 p.CategoryID into
 g
      select
 new
 {
           g.Key,
           MostExpensiveProducts =
               from
 p2 in
 g
               where
 p2.UnitPrice == g.Max(p3 => p3.UnitPrice)
               select
 p2
      };

Average

说明 ：返回集合中的数值类型元素的平均值。集合应为数字类型集合，其返回值类型为double；不延迟。生成SQL语句为：SELECT AVG(…) FROM

1.简单形式：

var
 q = db.Orders.Select(o => o.Freight).Average();

2.映射形式：

var
 q = db.Products.Average(p => p.UnitPrice);

3.原理：

var
 categories =
      from
 p in
 db.Products
      group
 p by
 p.CategoryID into
 g
      select
 new
 {
           g.Key,
           ExpensiveProducts =
               from
 p2 in
 g
               where
 p2.UnitPrice > g.Average(p3 => p3.UnitPrice)
               select
 p2
      };

Aggregate

说明 ：根据输入的表达式获取聚合值；不延迟。即是说：用一个种子值与当前元素通过指定的函数来进行对比来遍历集合中的元素，符合条件的元素保留下来。如果没有指定种子值的话，种子值默认为集合的第一个元素。

下面用一个表格总结一下这篇说的LINQ语句

 

Where	过滤；延迟
Select	选择；延迟
Distinct	查询不重复的结果集；延迟
Count	返回集合中的元素个数，返回INT类型；不延迟
LongCount	返回集合中的元素个数，返回LONG类型；不延迟
Sum	返回集合中数值类型元素之和，集合应为INT类型集合；不延迟
Min	返回集合中元素的最小值；不延迟
Max	返回集合中元素的最大值；不延迟
Average	返回集合中的数值类型元素的平均值。集合应为数字类型集合，其返回值类型为double；不延迟
Aggregate	根据输入的表达式获取聚合值；不延迟