C#3.0入门系列(三)

转载 2007年09月12日 14:56:00

 GroupBy操作

换一种写作风格。本节讲groupby操作。

在所有的Linq To Sql操作中,GroupBy是最难理解的一个。因为,这里和Sql的出入较大。而Group真的就能返回n多组。
打开vs,新建一工程,加入System.Data.Linq.dll的引用。把northwind数据库做个映射,添加到工程里。创建一Northwind类的对象。在这里呢,我们要做分组统计,我们要先明白什么是分组。在我们开始设计product表时,我们欲留了一列叫做CategoryID 这个字段,代表了这条记录中的产品,归属于那个类别。如图,字段的设计。

可以简单的举例,比如,当CategoryID的值为1时,就表示,对应的记录的产品是饮料类的。当它为2时,代表调味品类的。具体代表那一类,要看事先的约定。一般会专门有个表来保存这个约定。在northwind中,用Categories 表来保存这个约定。下面是catagories表中的纪录。

Categories
Product表,通过CategoryID字段关联关系。也就是说,Product表中,CategoryID字段所代表的意思,保存在Categories 表中。好了,知道分组的概念了,我们开始分类统计吧。在Linq To Sql的所有操作中,groupby算是比较难理解的一个。我要友好的提醒你注意下这里的分组所用的字段哦,这个将来是要被用做继承的哦。
我们来看下面的例子。

    var q =
        from p 
in db.Products
        group p by p.CategoryID into g
        select g;

在这里,from p in db.Products 表示从表中将对象纪录取出来。p就是每一个产品。而后面一句,group p by p.CategoryID into g表示对p进行归类,按什么归类呢,就是要按我们设定的CategoryID这个字段。而这个归类的结果,被重新命名为g,而且是必须重新命名。一旦重新命名,p的作用域就结束了,所以,最后select时,只能select g。
那有人就要问了,不重新命名可以吗?回答,可以。那你的select语句就没有了,上面语句等同与
整个查询语句返回八个组,这和我们数据库的八种产品是对应的。找到最后一个group,点开+号,我们可以看到,里面有个Key和Results View字段,其中Key为8,是数据库里对应的Seafood分类,点开Results View你会惊奇的发现,所有的Seafood都在里面。我们把代码改一下,看看dlinq究竟做了什么。

            var q = from p in db.Products
                    group p by p.CategoryID;

这是query表达式中,很少见的没有select语句的情况。我记忆中,好像只有此一种。我们还是按
    var q =
        from p in db.Products
        group p by p.CategoryID into g
        select g;
来讲解。因为这种更好理解。在T-Sql中,groupby只是用来做分组统计,计算平均值,最大值,求和等等,而在dlinq中的groupby,则发挥到了极值。我们用ToList()取到结果,来看看上面语句返回的结果。如图:


            Northwind db 
= new Northwind(ConStr);
            db.Log 
= Console.Out;
            
#region Query
            var q 
= from p in db.Products
                    group p by p.CategoryID into g
                    select g;
            
            
#endregion
 Query
            
#region Verification
            
foreach (var gp in q)
            
{

            }

            
return;
            
#endregion
 Verification

 单步调试该foreach段代码,foreach的目的是让dlinq加载数据。在console windows上,你可以看到如下输出。

SELECT [t0].[CategoryID] AS [Key]
FROM [Products] AS [t0]
GROUP BY [t0].[CategoryID]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

SELECT [t0].[ProductID][t0].[ProductName][t0].[SupplierID][t0].[CategoryID
][t0].[QuantityPerUnit][t0].[UnitPrice][t0].[UnitsInStock][t0].[UnitsOnO
rder
][t0].[ReorderLevel][t0].[Discontinued]
FROM [Products] AS [t0]
WHERE ((@x1 IS NULLAND ([t0].[CategoryID] IS NULL)) OR ((@x1 IS NOT NULLAND
(
[t0].[CategoryID] IS NOT NULLAND (@x1 = [t0].[CategoryID]))
-- @x1: Input Int32 (Size = 0; Prec = 0; Scale = 0) [1]
--
 Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

原来dlinq不仅仅是做了一个groupby操作呀,他还针对每个组,都去做了一个遍历呀。我们可以用下面的图来理解。

外面的大圈,表示全集。而这个全集被分成了若干个小的集合。每个集合就叫做g。在g集合中,包含一个系统定义的Property,叫做Key。key值实际为分类时所用字段的值。而另外一部分,是该类别中所有的product.所以,我们如果想遍历某类别中所有的纪录,要这么来做。

            var q = from p in db.Products
                    
group p by p.CategoryID into g
                    
select g;            

            foreach (
var gp in q)
            {
                
if (gp.Key == 7)
                {
                    foreach (
var p in gp)
                    { 
                     
//do something
                    }
                }
            }


 

有朋友反馈说我提供的sample不能编译。大概是版本的问题,可以到http://msdn2.microsoft.com/en-us/bb330936.aspx下载for beta1的版本。本节接着讲groupby。
上一节,我们讲了如何理解groupby返回的结果。本节会延这个思路阐述下去。先来看下面的例子

GroupBy操作中Select的匿名类

            var q = from p in db.Products
                    
group p by p.CategoryID into g
                    
select new { CategoryID = g.Key, g };

本例中,select操作中使用了匿名类。本系列中第一次提到匿名类是在http://www.cnblogs.com/126/archive/2006/12/20/503519.html 一文中。本文将再一次,阐述匿名类的理解。所谓匿名类,其实质,并不是匿名,而是编译器帮你去创建了这么一个类,在用户看来,好像并没有去创建,此所谓匿名类。也就是说,编译器在编译时,还是有这个类的,这个类是编译器自己创建的,其名称是编译器界定的。 在上例的匿名类中,有2个property,一个叫CategoryID, 一个叫g。 大家要注意了,这个匿名类,其实质是对返回结果重新进行了包装。而那个叫做g的property,就封装了一个完整的分组。如图,仔细比较和上篇图的区别。

如果,使用下面的语句。

            var q = from p in db.Products
                    
group p by p.CategoryID into g
                    
select new { CategoryID = g.Key,GroupSet = g };

只是把g重新命名为GroupSet.需要用下面的遍历,获取每个产品纪录。

            foreach (var gp in q)
            
{
                
if (gp.CategoryID == 7)
                
{   
                    
foreach (var p in gp.GroupSet)
                    

                    
                    }

                }

            }

这里groupby的操作相对难理解些,主要原因,它包含了整个分组的具体信息,而不是简单的求和,取平均值等。如果在最终结果中,也就是在select语句中,不包含g的全部信息,而只是g的聚合函数。又会是怎么样的一番风景呢?
GroupBy中的Max, Min, Sum, Average,Count
如果,只想取每类产品中,单价为最大,用T-sql该怎么办呢?是不是要这么来写

SELECT MAX([t0].[UnitPrice]AS [MaxPrice][t0].[CategoryID]
FROM [dbo].[Products] AS [t0]
GROUP BY [t0].[CategoryID]

我们来看看,dlinq如何来做同样的事情.如下,先按CategoryID归类,然后,只取CategoryID值和同类产品中单价最大的。

    var q =
        
from p in db.Products
        
group p by p.CategoryID into g
        
select new {
            g.
Key,
            MaxPrice 
= g.Max(p => p.UnitPrice)
        };

在这里,Max函数只对每个分组进行操作。我们来看看其结果

呀,这次,dlinq并没有把组里所有的纪录都取出来的吗。(请参考http://www.cnblogs.com/126/archive/2006/09/01/486388.html一文中的方法,配置sample.) dlinq只是简单做了统计,并返回结果。
每类产品中,单价为最小的,

    var q =
        
from p in db.Products
        
group p by p.CategoryID into g
        
select new {
            g.
Key,
            MinPrice 
= g.Min(p => p.UnitPrice)
        };

每类产品的价格平均值

    var q =
        
from p in db.Products
        
group p by p.CategoryID into g
        
select new {
            g.
Key,
            AveragePrice 
= g.Average(p => p.UnitPrice)
        };

每类产品,价格之和

    var q =
        
from p in db.Products
        
group p by p.CategoryID into g
        
select new {
            g.
Key,
            TotalPrice 
= g.Sum(p => p.UnitPrice)
        };

各类产品,数量之和

    var q =
        
from p in db.Products
        
group p by p.CategoryID into g
        
select new {
            g.
Key,
            NumProducts 
= g.Count()
        };

如果用OrderDetails表做统计,会更好些,因为,不光可以统计同一种产品,还可以统计同一订单。
接着统计,同各类产品中,断货的产品数量。使用下面的语句。

    var q =
        
from p in db.Products
        
group p by p.CategoryID into g
        
select new {
            g.
Key,
            NumProducts 
= g.Count(p => p.Discontinued)
        };

在这里,count函数里,使用了Lambda表达式。在上篇中,我们已经阐述了g是一个组的概念。那在该Lambda表达式中的p,就代表这个组里的一个元素或对象,即某一个产品。还可以使用where条件来限制最终筛选结果

    var q =
        
from p in db.Products
        
group p by p.CategoryID into g
        
where g.Count() >= 10
        
select new {
            g.
Key,
            ProductCount 
= g.Count()
        };

这句在翻译成sql语句时,欠套了一层,在最外层加了条件。

SELECT [t1].[CategoryID][t1].[value2] AS [ProductCount]
FROM (
    
SELECT COUNT(*AS [value]COUNT(*AS [value2][t0].[CategoryID]
    
FROM [dbo].[Products] AS [t0]
    
GROUP BY [t0].[CategoryID]
    ) 
AS [t1]
WHERE [t1].[value] >= @p0
-- @p0: Input Int32 (Size = 0; Prec = 0; Scale = 0) [10]
--
 Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

GroupBy操作中GroupBy的匿名类
第一次谈到匿名类时,我们就提到不光Select操作可以使用匿名类,其他操作符也可以。但是,OrderBy不支持。请参考C#3.0入门系列(六)-之OrderBy操作

当用户既想按产品的分类,又想按供应商来做分组,该怎么办呢。这时,我们就该使用匿名类。

    var categories =
        
from p in db.Products
        
group p by new { p.CategoryID, p.SupplierID } into g
        
select new {g.Key, g};

在by后面,new出来一个匿名类。这里,Key其实质是一个类的对象,Key包含两个Property,一个是CategoryID,再一个是SupplierID ,要想取到具体CategoryID的值,需要g.Key.CategoryID,才能访问到。我们来看dlinq翻译的T-sql语句。

SELECT [t0].[SupplierID][t0].[CategoryID]
FROM [dbo].[Products] AS [t0]
GROUP BY [t0].[CategoryID][t0].[SupplierID]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

先按CategoryID,再按SupplierID ,和匿名类中的循序一样。
最后一个例子。

    var categories =
        
from p in db.Products
        
group p by new { Criterion = p.UnitPrice > 10 } into g
        
select g;

按产品单价是否大于10分类。其结果为两类,大于的是一类,小于及等于为另一类。好了,剩下的,大家自己多去领会。
Join操作

 本节讲join操作。我们知道,T-sql中,有三种最基本的join,inner join, left join, 和right join。 而dlinq并不支持right join。道理很简单,right join以right表为基础,left表中没有对应记录的,将以null值填充。而dlinq以left表做为主表创建对象。如果一个对象为null,你如何获取它的其他的属性呢?

C# 3.0入门系列(四)-之Select操作一文中,我们提到了query expression首先会被翻译成标准的API, 而dlinq在join操作中,一共为我们提供了三个API.它们是Join, SelectMany和GroupJoin

Join
在101 的sample中,并没有join的例子。当一个query expression 有join字句时,而没有into字句,它将会被翻译成join方法。如,以Customers为主表,Orders为子表,用CustomerID 做关联进行join操作。

            var q =
    
from c in db.Customers
    
join o in db.Orders on c.CustomerID equals o.CustomerID

    
select new { c.CustomerID, o.EmployeeID };

它将会被翻译成

var q = db.Customers.Join(db.Orders, c => c.CustomerID, o => o.CustomerID, (c, o) => new { c.CustomerID, o.EmployeeID });

join方法的第一个参数,为子表,第二个参数,表示主表中的选择键,第三个参数为子表中的对应键,第四个为最终筛选结果。大家需要注意的时,因为参数的顺序是确定的,所以在写dlinq语句时,c.CustomerID equals o.CustomerID 的顺序是不能变的。
该语句所产生的T-sql语句为

SELECT [t0].[CustomerID][t1].[EmployeeID]
FROM [Customers] AS [t0]
INNER JOIN [Orders] AS [t1] ON [t0].[CustomerID] = [t1].[CustomerID]


SelectMany
在101sample中,给了4个SelectMany的例子。会被翻译成SelectMany需要满足2个条件。1,query语句中没有join和into,2,必须出现EntitySet。 关于EntitySet,请参考C#3.0进阶系列(一)-从映射讲起
先看第一个例子

    var q =
        
from c in db.Customers
        
from o in c.Orders
        
where c.City == "London"
        
select o;

Customers与Orders是1:M的关系。即Orders在Customers类中,以EntitySet出现。所以第二个from是从c.Orders而不是db.Orders里进行筛选。定义了他们关系的Mapping Code用Attribute保存了他们的关系。如
[Association(Name="Order_OrderDetail", Storage="_OrderDetails", OtherKey="OrderID")]
[Association(Name="Order_OrderDetail", Storage="_Order", ThisKey="OrderID", IsForeignKey=true)]
所以,你就不用担心,dlinq是否知道该按那个键进行关联。有兴趣的朋友,可以自己修改这里的OtherKey和ThisKey的值,看看翻译的T-sql语句是否变了。
第二个例子

    var q =
        
from p in db.Products
        
where p.Supplier.Country == "USA" && p.UnitsInStock == 0
        
select p;

这个例子,直接就使用了p.Supplier.Country 做条件,这样,也间接关联了Supplier表。该语句生成的T-sql语句更是值得揣摩,这大概是Left Out Join 的最简单的Dlinq语句。

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] = @p0AND ([t0].[UnitsInStock] = @p1)
-- @p0: Input String (Size = 3; Prec = 0; Scale = 0) [USA]
--
 @p1: Input Int32 (Size = 0; Prec = 0; Scale = 0) [0]
--
 Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

第三个例子是M : M的关系

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

M:M的关系,一般会涉及三个表。(如果,有一个表是自关联的,那有可能只有2个表。)在这里,涉及Employees, EmployeeTerritories, Territories共三个表。它们的关系是1 : M : 1. Employees和Territories没有很明确的关系。这个例子和上一个不同的是,它是在Select字句中,牵扯到Territories表。其生成的T-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] = @p0AND ([t1].[EmployeeID] = [t0].[EmployeeID])
-- @p0: Input String (Size = 7; Prec = 0; Scale = 0) [Seattle]
--
 Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

最后一个例子是自关联的,并且夹带了条件

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

其T-sql为

SELECT [t0].[FirstName][t0].[LastName][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])
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

从上面的例子我们可以看出,Dlinq以非常灵活的方式,处理其内部各表的关系。它不须显式的声明需要关联到那个表,也可以放在Where和Select等子句中,隐式关联。

GroupJoin
当dlinq语句中,有join而且还有into时,它会被翻译为GroupJoin.我们先来看第一个例子。

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

本系列曾在C#3.0入门系列(八)-之GroupBy操作 一文中,第一次谈到到into。into的概念是对其结果进行重新命名。为什么需要重新命名呢?我们以本例为例。One To Many的关系中,左边是one,它每条记录叫做c(from c in db.Customers),右边是many,其每条记录叫做o ( join o in db.Orders ),每对应左边的一个c,都会有一组o,那这一组o,就叫做orders,也就是说,我们把一组o命名为orders,这就是into用途。(和groupby中类似)。这也就是为什么在select语句中,orders可以调用聚合函数Count。

在这个例子中,翻译的t-sql为

SELECT [t0].[ContactName], (
    
SELECT COUNT(*)
    
FROM [dbo].[Orders] AS [t1]
    
WHERE [t0].[CustomerID] = [t1].[CustomerID]
    ) 
AS [value]
FROM [dbo].[Customers] AS [t0]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

dlinq很聪明,直接用其内欠的t-sql返回值作为字段值。
第二个例子


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

三个表联合查询。在其join语句后,紧跟着又是一个join.只是表多了些,并没有太多新鲜的东西。
第三个例子

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

Left Out Join的标准写法。以Employees为左表,Orders 为右,Orders 表中为空时,填冲null值。在将join的结果重命名后,再使用DefaultEmpty()函数,对其再次查询。大家需要注意的时,其最后的结果中有个Order,因为from o in ords.DefaultIfEmpty() 是对ords组再一次遍历,所以,最后结果中的Order并不是一个集合。但是,如果没有from o in ords.DefaultIfEmpty() 这句,最后的select语句写成select new { e.FirstName, e.LastName, Order = ords }的话,那Order就是一个集合
上例翻译的T-sql 为

SELECT [t0].[FirstName][t0].[LastName][t2].[test][t2].[OrderID][t2].[CustomerID][t2].[EmployeeID][t2].[OrderDate][t2].[RequiredDate][t2].[ShippedDate][t2].[ShipVia][t2].[Freight][t2].[ShipName][t2].[ShipAddress][t2].[ShipCity][t2].[ShipRegion][t2].[ShipPostalCode][t2].[ShipCountry]
FROM [dbo].[Employees] AS [t0]
LEFT OUTER JOIN (
    
SELECT 1 AS [test][t1].[OrderID][t1].[CustomerID][t1].[EmployeeID][t1].[OrderDate][t1].[RequiredDate][t1].[ShippedDate][t1].[ShipVia][t1].[Freight][t1].[ShipName][t1].[ShipAddress][t1].[ShipCity][t1].[ShipRegion][t1].[ShipPostalCode][t1].[ShipCountry]
    
FROM [dbo].[Orders] AS [t1]
    ) 
AS [t2] ON [t0].[EmployeeID] = [t2].[EmployeeID]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

第四个例子,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};

let语句有点类似into,也是个重命名的概念。需要提醒大家的是,let只要是放在第一个from后,select语句前就是符合语法的。上面的语句和下面这条是等价的。

            var q =
                
from c in db.Customers
                let z 
= c.City + c.Country                
                
join o in db.Orders on c.CustomerID equals o.CustomerID into ords               
                
from o in ords
                
select new { c.ContactName, o.OrderID, z };

其产生的T-sql均为:

SELECT [t1].[ContactName][t2].[OrderID][t1].[value]
FROM (
    
SELECT [t0].[City] + [t0].[Country] AS [value][t0].[CustomerID][t0].[ContactName]
    
FROM [dbo].[Customers] AS [t0]
    ) 
AS [t1]
CROSS JOIN [dbo].[Orders] AS [t2]
WHERE [t1].[CustomerID] = [t2].[CustomerID]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

它也应该和下面的语句等价,但其翻译的T-sql语句稍微有所不同。

            var q =
                
from c in db.Customers                        
                
join o in db.Orders on c.CustomerID equals o.CustomerID into ords               
                
from o in ords
                let z 
= c.City + c.Country        
                
select new { c.ContactName, o.OrderID, z };

有兴趣的朋友可以研究下,其产生的T-sql 为

SELECT [t2].[ContactName][t2].[OrderID][t2].[value]
FROM (
    
SELECT [t0].[City] + [t0].[Country] AS [value][t0].[CustomerID][t0].[ContactName][t1].[OrderID][t1].[CustomerID] AS [CustomerID2]
    
FROM [Customers] AS [t0][Orders] AS [t1]
    ) 
AS [t2]
WHERE [t2].[CustomerID] = [t2].[CustomerID2]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

第五个例子为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};

这里,它使用三个表,并且用匿名类来表示它们之间的关系。因为,其之间的关系已经不是一个键可以描述清楚的,所以只有用匿名类,表示组合键。这个例子有点像SelectMany中的ManyToMany的那个。
还有一种composite key的,就是两个表之间是用composite key表示关系的。这种情况很简单,不需像该例中使用匿名类。该例翻译的T-sql为

SELECT [t0].[OrderID][t1].[ProductID][t2].[UnitPrice]
FROM [dbo].[Orders] AS [t0][dbo].[Products] AS [t1][dbo].[Order Details] AS [t2]
WHERE ([t0].[OrderID] = [t2].[OrderID]AND ([t1].[ProductID] = [t2].[ProductID])
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

最后一个例子,没有看出什么好玩的来,不讲了。

写到这里,c#3.0的入门系列已经接近尾声了。我们一起学习了Dlinq的最基本操作。还剩下Union, In, Like还有一些聚合函数等操作。将会在下面几章中介绍。不知道大家对什么还感兴趣的,或者我能够提供帮助的,尽管问。
关于Linq To Sql 中的,Create, update, Delete 操作,以及Store procedure 及UDF等,更像是运用函数,而不是语言。所以,不在C#语言中讲。在考虑是不是开个什么Linq To Sql的深入应用。
写blog是对自己个人知识的总结,也是对自己表达功底的考验。因本人水平有限,错误再所难免,还请大家指出并谅解。

In, Like操作

有这么一个例子,寻找一个表中的某个字段介于某个给定的集合该怎么办?Sql写起来很简单,比如:Select * from table where id in (2,3, 4, 5)。 就是寻找id字段为这个给定的集合(2,3, 4, 5)内的值。那Linq to Sql该怎么做呢?一个字,简单。

In Operator 
比如,我们想要查找,"AROUT", "BOLID" 和 "FISSA" 这三个客户的订单。该如何做呢?Linq to Sql是这么做的。

        string[] customerID_Set = new string[] { "AROUT", "BOLID", "FISSA" };

        
var q = (from o in db.Orders
                 
where customerID_Set.Contains(o.CustomerID)
                 
select o).ToList();

其生成的sql语句为

SELECT [t0].[OrderID][t0].[CustomerID][t0].[EmployeeID][t0].[OrderDate][
t0
].[RequiredDate][t0].[ShippedDate][t0].[ShipVia][t0].[Freight][t0].[Sh
ipName
][t0].[ShipAddress][t0].[ShipCity][t0].[ShipRegion][t0].[ShipPosta
lCode
][t0].[ShipCountry]
FROM [dbo].[Orders] AS [t0]
WHERE [t0].[CustomerID] IN (@p0@p1@p2)
-- @p0: Input String (Size = 5; Prec = 0; Scale = 0) [AROUT]
--
 @p1: Input String (Size = 5; Prec = 0; Scale = 0) [BOLID]
--
 @p2: Input String (Size = 5; Prec = 0; Scale = 0) [FISSA]

先定义了一个数组,在linq query中,使用Contains,也很好理解,就是这个数组,包含了所有的CustomerID, 即返回结果中,所有的CustomerID都在这个集合内。也就是in。 你也可以把数组的定义放在linq语句里。比如:

        var q = (from o in db.Orders
                 
where (new string[] { "AROUT", "BOLID", "FISSA" }).Contains(o.CustomerID)
                 
select o).ToList();

Not in 呢?加个取反就是

        var q2 = (from o in db.Orders
                 
where !(new string[] { "AROUT", "BOLID", "FISSA" }).Contains(o.CustomerID)
                 
select o).ToList();

就这么简单。

Like Operator
Like的操作,有点像in,但是,方向变了。什么意思呢。就是你给定一个字符串,去寻找数据中某个字段包含这个字符串。就是给定的字符串是某字段的子集。Sql Script是这么写的。

Selec * from table where id like '%AD%'
Selec 
* from table where id like '%AD'
Selec 
* from table where id like 'AD%'

上面的%是通配符,表示,该字段含有某个值,不知道的位置使用%代替。第一个是表示中间一段是AD,两头不清楚。第二个是结尾是AD,前面的不清楚。第三个相反,开头是AD,结尾不清楚。其对应的Linq 语句为

        var q = (from c in db.Customers
                 
where c.CustomerID.Contains("ROUT")
                 
select c).ToList();

其生成的sql为

SELECT [t0].[CustomerID][t0].[CompanyName][t0].[ContactName][t0].[ContactT
itle
][t0].[Address][t0].[City][t0].[Region][t0].[PostalCode][t0].[Coun
try
][t0].[Phone][t0].[Fax]
FROM [dbo].[Customers] AS [t0]
WHERE [t0].[CustomerID] LIKE @p0
-- @p0: Input String (Size = 6; Prec = 0; Scale = 0) [%ROUT%]

以ISSA结尾,头部通配:

        var q = (from c in db.Customers
                 
where c.CustomerID.EndsWith("ISSA")
                 
select c).ToList();

其生成的sql为

SELECT [t0].[CustomerID][t0].[CompanyName][t0].[ContactName][t0].[ContactT
itle
][t0].[Address][t0].[City][t0].[Region][t0].[PostalCode][t0].[Coun
try
][t0].[Phone][t0].[Fax]
FROM [dbo].[Customers] AS [t0]
WHERE [t0].[CustomerID] LIKE @p0
-- @p0: Input String (Size = 5; Prec = 0; Scale = 0) [%ISSA]

以ARO开始,尾部通配:

        var q = (from c in db.Customers
                 
where c.CustomerID.StartsWith("ARO")
                 
select c).ToList();

其生成的sql为

SELECT [t0].[CustomerID][t0].[CompanyName][t0].[ContactName][t0].[ContactT
itle
][t0].[Address][t0].[City][t0].[Region][t0].[PostalCode][t0].[Coun
try
][t0].[Phone][t0].[Fax]
FROM [dbo].[Customers] AS [t0]
WHERE [t0].[CustomerID] LIKE @p0
-- @p0: Input String (Size = 4; Prec = 0; Scale = 0) [ARO%]


Linq 还提供了一种方法,叫做SqlMethods.Like,需要先添加System.Data.Linq.SqlClient名称空间。上面的三个可以写成

       var q = (from c in db.Customers
                 
where SqlMethods.Like(c.CustomerID, "%ROUT%")
                 
select c).ToList();

这里,你需要自己填写通配符,告诉Linq你是如何匹配。比如

        var q = (from c in db.Customers
                 
where SqlMethods.Like(c.CustomerID, "%ISSA")
                 
select c).ToList();

再比如:

        var q = (from c in db.Customers
                 
where SqlMethods.Like(c.CustomerID, "ARO%")
                 
select c).ToList();

SqlMethods.Like最奇妙的地方,莫过于,自己定义的通配表达式,你可以在任何地方实现通配。比如

        var q = (from c in db.Customers
                 
where SqlMethods.Like(c.CustomerID, "A%O%T")
                 
select c).ToList();

其生成的sql为

SELECT [t0].[CustomerID][t0].[CompanyName][t0].[ContactName][t0].[ContactT
itle
][t0].[Address][t0].[City][t0].[Region][t0].[PostalCode][t0].[Coun
try
][t0].[Phone][t0].[Fax]
FROM [dbo].[Customers] AS [t0]
WHERE [t0].[CustomerID] LIKE @p0
-- @p0: Input String (Size = 5; Prec = 0; Scale = 0) [A%O%T]


就是最标准的知道以A开头,以T结尾,中间知道一个值O,其他就什么不知道了。就用这个。
SQL Server 定义了四种通配符,在这里都可以使用。它们是:

Wildcard character Description Example
% Any string of zero or more characters. WHERE title LIKE '%computer%' finds all book titles with the word 'computer' anywhere in the book title.
_ (underscore) Any single character. WHERE au_fname LIKE '_ean' finds all four-letter first names that end with ean (Dean, Sean, and so on).
[ ] Any single character within the specified range ([a-f]) or set ([abcdef]). WHERE au_lname LIKE '[C-P]arsen' finds author last names ending with arsen and beginning with any single character between C and P, for example Carsen, Larsen, Karsen, and so on.
[^] Any single character not within the specified range ([^a-f]) or set ([^abcdef]). WHERE au_lname LIKE 'de[^l]%' all author last names beginning with de and where the following letter is not l.

%表示零长度或任意长度的字符串。_表示一个字符。[]表示在某范围区间的一个字符。[^]表示不在某范围区间的一个字符
比如:

        var q = (from c in db.Customers
                 
where SqlMethods.Like(c.CustomerID, "A_O_T")
                 
select c).ToList();

就用_代表一个字符。其生成sql为

SELECT [t0].[CustomerID][t0].[CompanyName][t0].[ContactName][t0].[ContactT
itle
][t0].[Address][t0].[City][t0].[Region][t0].[PostalCode][t0].[Coun
try
][t0].[Phone][t0].[Fax]
FROM [dbo].[Customers] AS [t0]
WHERE [t0].[CustomerID] LIKE @p0
-- @p0: Input String (Size = 5; Prec = 0; Scale = 0) [A_O_T]


对于Not Like,也很简单,加个取非就是。

        var q = (from c in db.Customers
                 
where !SqlMethods.Like(c.CustomerID, "A_O_T")
                 
select c).ToList();


SqlMethods.Like还有一个参数,叫escape Character,其将会被翻译成类似下面的语句。

SELECT columns FROM table WHERE 
    
column LIKE '%/%%' ESCAPE '/'

escape 是因为某字段中含有特殊字符,比如%,_ [ ]这些被用作通配符的。这时就要用到Escape了。这是sql server的事情了。详细情况请参考:
http://msdn2.microsoft.com/en-us/library/Aa933232(SQL.80).aspx

相关文章推荐

C#3.0新特性(三)- 详说自动属性和匿名类型

一、自动实现的属性   全称应该叫自动实现的属性(Auto-implemented properties),在上一篇中,给了简单的例子,说的是当属性访问器中不需要其他逻辑时,自动实现的属性可使属性声明...

C#3.0 之 自动属性 对象初始化器,集合初始器,扩展方法

批注:1)自动属性:可以减少自定义属性的代码量,但是不能在get/set容器中,进行内部的处理,使得属性对外部和对内部必须一致。如下无法使用自动属性:///使用 Pers...

LINQ&EF任我行(一)--C#3.0与LinQ

LinQ家族五大成员: LinQ to Objects - 默认功能,用来实现对内存中集合对象的查询 LinQ to SQL - 针对SQL Server的查询,它是一个带有可视化的操作界面的ORM工...

c#3.0新特性使用lambda表达式创建表达式树

c#3.0新特性使用lambda表达式创建表达式树2009年8月18日 云飞扬 发表评论 阅读评论 -c#3.0新特性使用lambda表达式创建表达式树题外话:这空间访问速度真慢,在我发布文章的时候,...
  • rise51
  • rise51
  • 2011年01月19日 18:02
  • 220

C#3.0新特性速览(1)

微软最近的动作频繁,C#2.0规范才刚推出不久,我还没来的及完全消化C#2.0中的所有新特性,而今又推出了C#3.0,在短短几年中,微软就对C# 进行了两次大的升级,为C#加入了许多新的特性,从而使C...

C#3.0 对象与集合初始化器(Object and Collection Initializers)

 对象初始化器 (Object Initializers) :.NET2.0框架中的类型非常依赖于属性。当生成对象实例和使用新的类型时,在.Net2.0时候我们像这样写:User user = new...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C#3.0入门系列(三)
举报原因:
原因补充:

(最多只允许输入30个字)