查询表达式(LINQ)简介

查询表达式(LINQ)简介


LINQ是Language Integrated
Query的简称，它是集成在.NET编程语言中的一种特性。已成为编程语言的一个组成部分，在编写程序时可以得到很好的编译时语法检查，丰富的元数据，
智能感知、静态类型等强类型语言的好处。并且它同时还使得查询可以方便地对内存中的信息进行查询而不仅仅只是外部数据源。

LINQ定义了一组标准查询操作符用于在所有基于.NET平台的编程语言中更加直接地声明跨越、过滤和投射操作的统一方式，标准查询操作符允许查询
作用于所有基于IEnumerable<T>接口的源，并且它还允许适合于目标域或技术的第三方特定域操作符来扩大标准查询操作符集，更重要
的是，第三方操作符可以用它们自己的提供附加服务的实现来自由地替换标准查询操作符，根据LINQ模式的习俗，这些查询喜欢采用与标准查询操作符相同的语
言集成和工具支持。

我们来总体看看LINQ架构



在.NET3.5下，微软为我们提供了一些命名空间



LINQ包括五个部分：LINQ to Objects、LINQ to DataSets、LINQ to SQL、LINQ to Entities、LINQ to XML。

LINQ to
SQL全称基于关系数据的.NET语言集成查询，用于以对象形式管理关系数据，并提供了丰富的查询功能。其建立于公共语言类型系统中的基于SQL的模式定
义的集成之上，当保持关系型模型表达能力和对底层存储的直接查询评测的性能时，这个集成在关系型数据之上提供强类型。

LINQ to XML在System.Xml.LINQ命名空间下实现对XML的操作。采用高效、易用、内存中的XML工具在宿主编程语言中提供XPath/XQuery功能等。

说了这么多，我们还是用一个简单的实例说明一下LINQ带来的体验。

第一步：建立dbml（Database Mark Language。数据库描述语言，是一种xml格式的文档，用来描述数据库）文件，以Northwind数据库为例，上述Customers类被映射成一个表，对应数据库中的 Customers表



第二步：创建一个ASP.NET页面，在页面上加入一个GridView控件



第三步：编写代码进行数据绑定



第四步：运行显示结果。



接下来，我们开始从LINQ to SQL语句入手，来全面了解一下LINQ，就从最简单的Where说起吧，这个在编写程序中也最为常用。

Where操作

适用场景：实现过滤，查询等功能。

说明：与SQL命令中的Where作用相似，都是起到范围限定也就是过滤作用的，而判断条件就是它后面所接的子句。

Where操作包括3种形式，分别为简单形式、关系条件形式、First()形式。下面分别用实例举例下：

1.简单形式：

例如：使用where筛选在伦敦的客户

var q =

from c in db.Customers

where c.City == "London"

select c;再如：筛选1994 年或之后雇用的雇员：

var q =

from e in db.Employees

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

select e;2.关系条件形式：

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

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);3.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);

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();语句描述：查询顾客覆盖的国家。

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 to SQL语句

Where 过滤；延迟

Select 选择；延迟

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

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

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

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

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

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

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

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

Join操作

适用场景：在我们表关系中有一对一关系，一对多关系，多对多关系等。对各个表之间的关系，就用这些实现对多个表的操作。

说明：在Join操作中，分别为Join(Join查询), SelectMany(Select一对多选择)和GroupJoin(分组Join查询)。

该扩展方法对两个序列中键匹配的元素进行inner join操作

SelectMany

说明：我们在写查询语句时，如果被翻译成SelectMany需要满足2个条件。1：查询语句中没有join和into，2：必须出现EntitySet。在我们表关系中有一对一关系，一对多关系，多对多关系等，下面分别介绍一下。

1.一对多关系(1 to Many)：

var q =

from c in db.Customers

from o in c.Orders

where c.City == "London"

select
o;语句描述：Customers与Orders是一对多关系。即Orders在Customers类中以EntitySet形式出现。所以第二个
from是从c.Orders而不是db.Orders里进行筛选。这个例子在From子句中使用外键导航选择伦敦客户的所有订单。

var q =

from p in db.Products

where p.Supplier.Country == "USA" && p.UnitsInStock == 0

select p;语句描述：这一句使用了p.Supplier.Country条件，间接关联了Supplier表。这个例子在Where子句中使用外键导航筛选其供应商在美国且缺货的产品。生成SQL语句为：

SELECT [t0].[ProductID], [t0].[ProductName], [t0].[SupplierID],

[t0].[CategoryID],[t0].[QuantityPerUnit],[t0].[UnitPrice],

[t0].[UnitsInStock], [t0].[UnitsOnOrder],[t0].[ReorderLevel],

[t0].[Discontinued] FROM [dbo].[Products] AS [t0]

LEFT OUTER JOIN [dbo].[Suppliers] AS [t1] ON

[t1].[SupplierID] = [t0].[SupplierID]

WHERE ([t1].[Country] = @p0) AND ([t0].[UnitsInStock] = @p1)

-- @p0: Input NVarChar (Size = 3; Prec = 0; Scale = 0) [USA]

-- @p1: Input Int (Size = 0; Prec = 0; Scale = 0) [0]2.多对多关系(Many to Many)：

var q =

from e in db.Employees

from et in e.EmployeeTerritories

where e.City == "Seattle"

select new

{

e.FirstName,

e.LastName,

et.Territory.TerritoryDescription

};说明：多对多关系一般会涉及三个表(如果有一个表是自关联的，那有可能只有2个表)。这一句语句涉及Employees,
EmployeeTerritories,
Territories三个表。它们的关系是1：M：1。Employees和Territories没有很明确的关系。

语句描述：这个例子在From子句中使用外键导航筛选在西雅图的雇员，同时列出其所在地区。这条生成SQL语句为：

SELECT [t0].[FirstName], [t0].[LastName], [t2].[TerritoryDescription]

FROM [dbo].[Employees] AS [t0] CROSS JOIN [dbo].[EmployeeTerritories]

AS [t1] INNER JOIN [dbo].[Territories] AS [t2] ON

[t2].[TerritoryID] = [t1].[TerritoryID]

WHERE ([t0].[City] = @p0) AND ([t1].[EmployeeID] = [t0].[EmployeeID])

-- @p0: Input NVarChar (Size = 7; Prec = 0; Scale = 0) [Seattle]3.自联接关系：

var q =

from e1 in db.Employees

from e2 in e1.Employees

where e1.City == e2.City

select new {

FirstName1 = e1.FirstName, LastName1 = e1.LastName,

FirstName2 = e2.FirstName, LastName2 = e2.LastName,

e1.City

};语句描述：这个例子在select 子句中使用外键导航筛选成对的雇员，每对中一个雇员隶属于另一个雇员，且两个雇员都来自相同城市。生成SQL语句为：

SELECT [t0].[FirstName] AS [FirstName1], [t0].[LastName] AS

[LastName1],[t1].[FirstName] AS [FirstName2], [t1].[LastName] AS

[LastName2],[t0].[City] FROM [dbo].[Employees] AS [t0],

[dbo].[Employees] AS [t1] WHERE ([t0].[City] = [t1].[City]) AND

([t1].[ReportsTo] = [t0].[EmployeeID])GroupJoin

像上面所说的，没有join和into，被翻译成SelectMany，同时有join和into时，那么就被翻译为GroupJoin。在这里into的概念是对其结果进行重新命名。

1.双向联接(Two way join)：

此示例显式联接两个表并从这两个表投影出结果：

var q =

from c in db.Customers

join o in db.Orders on c.CustomerID

equals o.CustomerID into orders

select new

{

c.ContactName,

OrderCount = orders.Count()

};说明：在一对多关系中，左边是1，它每条记录为c（from c in db.Customers），右边是Many，其每条记录叫做o
( join o in db.Orders
)，每对应左边的一个c，就会有一组o，那这一组o，就叫做orders，也就是说，我们把一组o命名为orders，这就是into用途。这也就是为什
么在select语句中，orders可以调用聚合函数Count。在T-SQL中，使用其内嵌的T-SQL返回值作为字段值。如图所示：



生成SQL语句为：

SELECT [t0].[ContactName], (

SELECT COUNT(*)

FROM [dbo].[Orders] AS [t1]

WHERE [t0].[CustomerID] = [t1].[CustomerID]

) AS [OrderCount]

FROM [dbo].[Customers] AS [t0]2.三向联接(There way join)：

此示例显式联接三个表并分别从每个表投影出结果：

var q =

from c in db.Customers

join o in db.Orders on c.CustomerID

equals o.CustomerID into ords

join e in db.Employees on c.City

equals e.City into emps

select new

{

c.ContactName,

ords = ords.Count(),

emps = emps.Count()

};生成SQL语句为：

SELECT [t0].[ContactName], (

SELECT COUNT(*)

FROM [dbo].[Orders] AS [t1]

WHERE [t0].[CustomerID] = [t1].[CustomerID]

) AS [ords], (

SELECT COUNT(*)

FROM [dbo].[Employees] AS [t2]

WHERE [t0].[City] = [t2].[City]

) AS [emps]

FROM [dbo].[Customers] AS [t0]3.左外部联接(Left Outer Join)：

此示例说明如何通过使用 此示例说明如何通过使用DefaultIfEmpty() 获取左外部联接。在雇员没有订单时，DefaultIfEmpty()方法返回null：

var q =

from e in db.Employees

join o in db.Orders on e equals o.Employee into ords

from o in ords.DefaultIfEmpty()

select new

{

e.FirstName,

e.LastName,

Order = o

};说明：以Employees左表，Orders右表，Orders
表中为空时，用null值填充。Join的结果重命名ords，使用DefaultIfEmpty()函数对其再次查询。其最后的结果中有个Order，
因为from o in ords.DefaultIfEmpty()
是对ords组再一次遍历，所以，最后结果中的Order并不是一个集合。但是，如果没有from o in
ords.DefaultIfEmpty() 这句，最后的select语句写成select new { e.FirstName,
e.LastName, Order = ords }的话，那么Order就是一个集合。

4.投影的Let赋值(Projected let assignment)：

说明：let语句是重命名。let位于第一个from和select语句之间。

这个例子从联接投影出最终“Let”表达式：

var q =

from c in db.Customers

join o in db.Orders on c.CustomerID

equals o.CustomerID into ords

let z = c.City + c.Country

from o in ords

select new

{

c.ContactName,

o.OrderID,

z

};5.组合键(Composite Key)：

这个例子显示带有组合键的联接：

var q =

from o in db.Orders

from p in db.Products

join d in db.OrderDetails

on new

{

o.OrderID,

p.ProductID

} equals

new

{

d.OrderID,

d.ProductID

}

into details

from d in details

select new

{

o.OrderID,

p.ProductID,

d.UnitPrice

};说明：使用三个表，并且用匿名类来说明：使用三个表，并且用匿名类来表示它们之间的关系。它们之间的关系不能用一个键描述清楚，所以用匿名类，来表示组合键。还有一种是两个表之间是用组合键表示关系的，不需要使用匿名类。

6.可为null/不可为null的键关系(Nullable/Nonnullable Key Relationship)：

这个实例显示如何构造一侧可为 null 而另一侧不可为 null 的联接：

var q =

from o in db.Orders

join e in db.Employees

on o.EmployeeID equals

(int?)e.EmployeeID into emps

from e in emps

select new

{

o.OrderID,

e.FirstName

};Order By操作

适用场景：对查询出的语句进行排序，比如按时间排序等等。

说明：按指定表达式对集合排序；延迟，：按指定表达式对集合排序；延迟，默认是升序，加上descending表示降序，对应的扩展方法是OrderBy和OrderByDescending

1.简单形式

这个例子使用 orderby 按雇用日期对雇员进行排序：

var q =

from e in db.Employees

orderby e.HireDate

select e;说明：默认为升序

2.带条件形式

注意：Where和Order By的顺序并不重要。而在T-SQL中，Where和Order By有严格的位置限制。

var q =

from o in db.Orders

where o.ShipCity == "London"

orderby o.Freight

select o;语句描述：使用where和orderby按运费进行排序。

3.降序排序

var q =

from p in db.Products

orderby p.UnitPrice descending

select p;4.ThenBy

语句描述：使用复合的 orderby 对客户进行排序，进行排序：

var q =

from c in db.Customers

orderby c.City, c.ContactName

select c;说明：按多个表达式进行排序，例如先按City排序，当City相同时，按ContactName排序。这一句用Lambda表达式像这样写：

var q =

.OrderBy(c => c.City)

.ThenBy(c => c.ContactName).ToList();在T-SQL中没有ThenBy语句，其依然翻译为OrderBy，所以也可以用下面语句来表达：

var q =

db.Customers

.OrderBy(c => c.ContactName)

.OrderBy(c => c.City).ToList();所要注意的是，多个OrderBy操作时，级连方式是按逆序。对于降序的，用相应的降序操作符替换即可。

var q =

db.Customers

.OrderByDescending(c => c.City)

.ThenByDescending(c => c.ContactName).ToList();需要说明的是，OrderBy操作，不支持按type排序，也不支持匿名类。比如

var q =

db.Customers

.OrderBy(c => new

{

c.City,

c.ContactName

}).ToList();会被抛出异常。错误是前面的操作有匿名类，再跟OrderBy时，比较的是类别。比如

var q =

db.Customers

.Select(c => new

{

c.City,

c.Address

})

.OrderBy(c => c).ToList();如果你想使用OrderBy(c => c)，其前提条件是，前面步骤中，所产生的对象的类别必须为C#语言的基本类型。比如下句，这里City为string类型。

var q =

db.Customers

.Select(c => c.City)

.OrderBy(c => c).ToList();5.ThenByDescending

这两个扩展方式都是用在OrderBy/OrderByDescending之后的，第一个ThenBy/ThenByDescending扩展方法作为第二位排序依据，第二个ThenBy/ThenByDescending则作为第三位排序依据，以此类推

var q =

from o in db.Orders

where o.EmployeeID == 1

orderby o.ShipCountry, o.Freight descending

select o;语句描述：使用orderby先按发往国家再按运费从高到低的顺序对 EmployeeID 1 的订单进行排序。

6.带GroupBy形式

var q =

from p in db.Products

group p by p.CategoryID into g

orderby g.Key

select new {

g.Key,

MostExpensiveProducts =

from p2 in g

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

select p2

};语句描述：使用orderby、Max 和 Group By 得出每种类别中单价最高的产品，并按 CategoryID 对这组产品进行排序。