风影ASP.NET基础教学 14 LINQ TO SQL基础

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.UI;

using System.Web.UI.WebControls;

namespace WebApplication1

{

    public partial class WebForm1 : System.Web.UI.Page

    {

        protected void Page_Load(object sender, EventArgs e)

        {

            NorthwindEntities North = new NorthwindEntities();

            #region 基本语法

            //Linq 基本语法   from --- where--- select 

            //T-sql对应语法   select --- from --- where

            //var data = from p in North.Products

            //           where p.ProductID < 20

            //           select p;

            // select * from Products where Productid<20

            //var data =

            //    from c in North.Categories

            //    where c.CategoryID == 3

            //    select c;

            //晚于 1994年1月1日

            // from e in db.Employees

            // where e.HireDate >= new DateTime(1994, 1, 1)

            // select e;

            //var data = from p in North.Products

            //           where p.ProductID < 20

            //           select new {p.ProductName,p.ProductID,p.CategoryID};

            //select ProductName,ProductID,CategoryID from products where productid<20

            //var data = from p in North.Products

            //           where p.ProductID < 20

            //           select new { p.ProductName, p.ProductID, p.CategoryID };

            //this.GridView1.DataSource = data;

            //this.GridView1.DataBind();

            #endregion

            #region 关系条件形式

            //筛选库存量在订货点水平之下但未断货的产品：

            // var q =

            //    from p in db.Products

            //    where p.UnitsInStock <= p.ReorderLevel && !p.Discontinued

            //    select p;

            //筛选出UnitPrice 大于10 或已停产的产品：

            // var q =

            //    from p in db.Products

            //    where p.UnitPrice > 10m || p.Discontinued

            //    select p; 

            //下面这个例子是调用两次where以筛选出UnitPrice大于10且已停产的产品。

            //var q =

            //    db.Products.Where(p=>p.UnitPrice > 10m).Where(p=>p.Discontinued);

            #endregion

            #region First()形式

            //返回集合中的一个元素，其实质就是在SQL语句中加TOP (1)。

            //简单用法：选择表中的第一个发货方。

            // Shipper shipper = db.Shippers.First();

            //元素：选择CustomerID 为“BONAP”的单个客户

            // Customer cust = db.Customers.First(c => c.CustomerID == "BONAP");

            //条件：选择运费大于 10.00 的订单：

            // Order ord = db.Orders.First(o => o.Freight > 10.00M);

            #endregion

            #region Select/Distinct操作符详细讲解

            //适用场景：o(∩_∩)o… 查询呗。

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

            //Select/Distinct操作包括9种形式，分别为简单用法、 匿名类型形式、条件形式、指定类型形式、筛选形式、整形类型形式、 嵌套类型形式、本地方法调用形式、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 = "s" };编译器自动产生一个有property叫做Name的匿名类，然后按这个类型分配内存，并初始化对象。但是var d = new {"s"};是编译不通过的。因为，编译器不知道匿名类中的property的名字。例如string c = "d";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}; 

            //上面语句描述：使用 SELECT 和匿名类型返回仅含客户联系人姓名和电话号码的序列

            // var q =

            //    from e in db.Employees

            //    select new

            //    {

            //        Name = e.FirstName + " " + e.LastName,

            //        Phone = e.HomePhone

            //    }; 

            //上面语句描述：使用SELECT和匿名类型返回仅含雇员姓名和电话号码的序列，并将FirstName和LastName字段合并为一个字段“Name”，此外在所得的序列中将HomePhone字段重命名为Phone。

            // var q =

            //    from p in db.Products

            //    select new

            //    {

            //        p.ProductID,

            //        HalfPrice = p.UnitPrice / 2

            //    }; 

            //上面语句描述：使用SELECT和匿名类型返回所有产品的ID以及HalfPrice(设置为产品单价除以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"

            //    }; 

            //上面语句描述：使用SELECT和条件语句返回产品名称和产品供货状态的序列。

            //4.指定类型形式：

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

            // var q =

            //    from e in db.Employees

            //    select new Name

            //    {

            //        FirstName = e.FirstName,

            //        LastName = e.LastName

            //    }; 

            //上面语句描述：使用SELECT和已知类型返回雇员姓名的序列。

            //5.筛选形式：

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

            // var q =

            //    from c in db.Customers

            //    where c.City == "London"

            //    select c.ContactName; 

            //上面语句描述：使用SELECT和WHERE返回仅含伦敦客户联系人姓名的序列。

            //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}

            //    }; 

            //语句描述：使用SELECT 和匿名类型返回有关客户的数据的整形子集。查询顾客的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

            //    }; 

            //语句描述：使用嵌套查询返回所有订单及其OrderID 的序列、打折订单中项目的子序列以及免送货所省下的金额。

            //8.本地方法调用形式(LocalMethodCall)：

            //这个例子在查询中调用本地方法PhoneNumberConverter将电话号码转换为国际格式。

            //         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)

            //         }; 

            //        PhoneNumberConverter方法如下：

            //        public string PhoneNumberConverter(string Country, string Phone)

            //       {

            //             Phone = Phone.Replace(" ", "").Replace(")", ")-");

            //             switch (Country)

            //             {

            //                  case "USA":

            //                      return "1-" + Phone;

            //                  case "UK":

            //                      return "44-" + Phone;

            //                  default:

            //                      return Phone;

            //    }

            //} 

            //下面也是使用了这个方法将电话号码转换为国际格式并创建XDocument

            // 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(); 

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

            #endregion

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

            /*

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

             * Count

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

                1.简单形式：

                    得到数据库中客户的数量：

                    var q = db.Customers.Count(); 

                2.带条件形式：(Lambda)

                    得到数据库中未断货产品的数量：

                    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.UnitPrice into g

                        select new {

                                CategoryID = g.Key,

                                CheapestProducts =

                                    from p2 in g

                                    where p2.UnitPrice == g.Min(p3 => p3.UnitPrice)

                                    select p2

                       }; 

          // select CategoryID,min(price) from Products group by CategoryID

             * 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

                        }; 

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

下面 总结一下这篇说的LINQ to SQL语句

Where        过滤；延迟

Select        选择；延迟

Distinct      查询不重复的结果集；延迟

Count        返回集合中的元素个数，返回INT类型；不延迟

LongCount  返回集合中的元素个数，返回LONG类型；不延迟

Sum          返回集合中数值类型元素之和，集合应为INT类型集合；不延迟

Min           返回集合中元素的最小值；不延迟

Max           返回集合中元素的最大值；不延迟

Average      返回集合中的数值类型元素的平均值。集合应为数字类型集合，其返回值类型为double；不延迟

Aggregate   根据输入的表达式获取聚合值；不延迟

             */

            #endregion

        }

    }

}