|
|
Posted on 2007-10-15 08:25 webabcd 阅读(6932) 评论(24) 编辑 收藏 所属分类: LINQ
[索引页]
[源码下载]
步步为营VS 2008 + .NET 3.5(5) - LINQ查询操作符之Select、Where、OrderBy、OrderByDescending、GroupBy、Join、GroupJoin及其对应的查询语法
作者： webabcd
介绍
·Select - Select选择；延迟
·Where - Where查询；延迟
·OrderBy - 按指定表达式对集合正序排序；延迟
·OrderByDescending - 按指定表达式对集合倒序排序；延迟
·GroupBy - 分组；延迟
·Join - Join查询；延迟
·GroupJoin - 分组Join查询；延迟
·以上查询操作符所对应的查询语法
示例
Summary.aspx.cs
 using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Xml.Linq;
using System.Collections.Generic;
using DAL;
public partial class LINQ_Summary : System.Web.UI.Page
   {
 NorthwindDataContext _ctx = new NorthwindDataContext();
string[] _ary = null;
protected void Page_Load(object sender, EventArgs e)
  {
_ary = new string[] { "asp.net", "csharp", "xhtml", "css", "javascript",
"wcf", "wpf", "silverlight", "linq", "wf",
 "sqlserver", "asp.net ajax", "ssis", "ssas", "ssrs" };
// Select - Select选择；延迟
Summary_Select();
// Where - Where查询；延迟
Summary_Where();
// OrderBy - 按指定表达式对集合正序排序；延迟
// OrderByDescending - 按指定表达式对集合倒序排序；延迟
Summary_OrderBy_OrderByDescending();
// GroupBy - 分组；延迟
Summary_GroupBy();
// Join - Join查询；延迟
Summary_Join();
// GroupJoin - 分组Join查询；延迟
Summary_GroupJoin();
}
 } /**//// <summary>
/// Select - Select选择；延迟
/// </summary>
void Summary_Select()
{
// 使用Select查询操作符
var categories = _ctx.Categories.Select(
c => new { CategoryName = "类别名称：" + c.CategoryName });
foreach (var c in categories)
{
result.InnerHtml += c.CategoryName + "<br />";
}
result.InnerHtml += "<br />";
// 与上面的Select查询操作符相对应的查询语法
var categories2 = from c in _ctx.Categories
select new { CategoryName = "类别名称：" + c.CategoryName };
foreach (var c in categories2)
{
result.InnerHtml += c.CategoryName + "<br />";
}
result.InnerHtml += "<br />";
}
运行结果
类别名称：Beverages
类别名称：Condiments
类别名称：Confections
类别名称：Dairy Products
类别名称：Grains/Cereals
类别名称：Meat/Poultry
类别名称：Produce
类别名称：Seafood
Where - Where查询；延迟
/**//// <summary>
/// Where - Where查询；延迟
/// </summary>
void Summary_Where()
{
// 使用Where查询操作符
var ary = _ary.Where(a => a.StartsWith("w") && a.EndsWith("f"));
foreach (string s in ary)
{
result.InnerHtml += s + "<br />";
}
result.InnerHtml += "<br />";
// 与上面的Where查询操作符相对应的查询语法
var ary2 = from a in _ary
where a.StartsWith("w") && a.EndsWith("f")
select a;
foreach (string s in ary2)
{
result.InnerHtml += s + "<br />";
}
result.InnerHtml += "<br />";
}
运行结果
wcf
wpf
wf
OrderBy - 按指定表达式对集合正序排序；延迟
OrderByDescending - 按指定表达式对集合倒序排序；延迟
/**//// <summary>
/// OrderBy - 按指定表达式对集合正序排序；延迟
/// OrderByDescending - 按指定表达式对集合倒序排序；延迟
/// </summary>
void Summary_OrderBy_OrderByDescending()
{
// 使用OrderBy查询操作符
var ary = (from a in _ary
select a).OrderBy(a => a.Length); // OrderByDescending与OrderBy用法相同
foreach (string s in ary)
{
result.InnerHtml += s + "<br />";
}
result.InnerHtml += "<br />";
// 与上面的OrderBy查询操作符相对应的查询语法
var ary2 = from a in _ary
orderby a.Length ascending // orderby xxx descending与orderby xxx ascending用法相同
select a;
foreach (string s in ary2)
{
result.InnerHtml += s + "<br />";
}
result.InnerHtml += "<br />";
}
运行结果
wf
css
wcf
wpf
linq
ssis
ssas
ssrs
xhtml
csharp
asp.net
sqlserver
javascript
silverlight
asp.net ajax
GroupBy - 分组；延迟
/**//// <summary>
/// GroupBy - 分组；延迟
/// </summary>
void Summary_GroupBy()
{
// 使用GroupBy查询操作符
var list = (from a in _ary
select a).GroupBy(a => a.Length).Select(
g => new { Group = g.Key, Member = g });
foreach (var g in list)
{
result.InnerHtml += g.Group + "个字符：<br />";
foreach (string s in g.Member)
{
result.InnerHtml += "--" + s + "<br />";
}
}
result.InnerHtml += "<br />";
// 与上面的GroupBy查询操作符相对应的查询语法
var list2 = from a in _ary
group a by a.Length into g
select new { Group = g.Key, Member = g };
foreach (var g in list2)
{
result.InnerHtml += g.Group + "个字符：<br />";
foreach (string s in g.Member)
{
result.InnerHtml += "--" + s + "<br />";
}
}
result.InnerHtml += "<br />";
}
运行结果
7个字符：
--asp.net
6个字符：
--csharp
5个字符：
--xhtml
3个字符：
--css
--wcf
--wpf
10个字符：
--javascript
11个字符：
--silverlight
4个字符：
--linq
--ssis
--ssas
--ssrs
2个字符：
--wf
9个字符：
--sqlserver
12个字符：
--asp.net ajax
Join - Join查询；延迟
/**//// <summary>
/// Join - Join查询；延迟
/// </summary>
void Summary_Join()
{
// 使用Join查询操作符
var products = _ctx.Products.Join(
_ctx.Categories,
p => p.CategoryID,
c => c.CategoryID,
(p, c) => new { c.CategoryName, p.ProductName }).Take(5);
foreach (var p in products)
{
result.InnerHtml += p.CategoryName + " - " + p.ProductName + "<br />";
}
result.InnerHtml += "<br />";
// 与上面的Join查询操作符相对应的查询语法
var products2 = (from p in _ctx.Products
join c in _ctx.Categories
on p.CategoryID equals c.CategoryID
select new { c.CategoryName, p.ProductName }).Take(5);
foreach (var p in products2)
{
result.InnerHtml += p.CategoryName + " - " + p.ProductName + "<br />";
}
result.InnerHtml += "<br />";
}
运行结果
Beverages - Chai
Beverages - Chang
Condiments - Aniseed Syrup
Condiments - Chef Anton's Cajun Seasoning
Condiments - Chef Anton's Gumbo Mix
GroupJoin - 分组Join查询；延迟
/**//// <summary>
/// GroupJoin - 分组Join查询；延迟
/// </summary>
void Summary_GroupJoin()
{
// 使用GroupJoin查询操作符
var products = _ctx.Categories.GroupJoin(
_ctx.Products,
c => c.CategoryID,
p => p.CategoryID,
(p, g) => new { p.CategoryName, ProductCount = g.Count() });
foreach (var g in products)
{
result.InnerHtml += g.CategoryName + "：" + g.ProductCount + "<br />";
}
result.InnerHtml += "<br />";
// 与上面的GroupJoin查询操作符相对应的查询语法
var products2 = from c in _ctx.Categories
join p in _ctx.Products on c.CategoryID equals p.CategoryID into g
select new { CategoryName = c.CategoryName, ProductCount = g.Count() };
foreach (var g in products2)
{
result.InnerHtml += g.CategoryName + "：" + g.ProductCount + "<br />";
}
result.InnerHtml += "<br />";
}
运行结果
Beverages：12
Condiments：12
Confections：13
Dairy Products：10
Grains/Cereals：7
Meat/Poultry：6
Produce：5
Seafood：12
OK
[源码下载]
Feedback
@ivw
是的
这就是LINQ
有很多查询操作符
之后都会一一介绍一遍
麻烦兄弟能不能详细解释一下GroupJoin的意思
我指的是这句
var products = _ctx.Categories.GroupJoin(_ctx.Products, c => c.CategoryID, p => p.CategoryID, (p, g) => new { p.CategoryName, ProductCount = g.Count() });
GroupJoin里的参数都是什么意思啊
@黑白
第一个参数：需要被join的表
第二个参数：本表需要关联的key
第三个参数：被join的表需要关联的key
第四个参数：分组表达式（其中第一个参数：本表的实体；第二个参数：被join的表集合）
@webabcd
var products = _ctx.Categories.GroupJoin(_ctx.Products, c => c.CategoryID, p => p.CategoryID, (p, g) => new { p.CategoryName, ProductCount = g.Count() });
(p, g) 哪里来的g？， 怎么会有p.CategoryName?
应该是这样的
var products1 = this._ctx.Categories.GroupJoin(
this._ctx.Products,
c => c.CategoryID,
p => p.CategoryID,
(c, p) => new { c.CategoryName, ProductCount = p.Count() });
@Terry Sun
:)
var products = _ctx.Categories.GroupJoin(_ctx.Products, c => c.CategoryID, p => p.CategoryID, (p, g) => new { p.CategoryName, ProductCount = g.Count() });
前面的c，p和后面的p，g
其中的p并不是同一参数
也就是后面的(p, g)完全可以写成(x, y)，或其他的
GroupJoin - 分组Join查询；延迟
// 与上面的GroupJoin查询操作符相对应的查询语法
var products2 = from c in _ctx.Categories
join p in _ctx.Products on c.CategoryID equals p.CategoryID into g
select new { CategoryName = c.CategoryName, ProductCount = g.Count() };
这里有点问题。
c.CategoryName 这个应该是P.CategoryName。
还是我理解错误了？
理解了。我误解了
// 与上面的GroupJoin查询操作符相对应的查询语法
var products2 = from c in _ctx.Categories
join p in _ctx.Products on c.CategoryID equals p.CategoryID into g
select new { CategoryName = c.CategoryName, ProductCount = g.Count() };
不过又有新问题。这里 我怎么看不出来哪里有分组了？
这里不是将两个表数据关联后丢给g 然后就是 创建匿名类型数据，那么g.Count()的数据不都是一样的吗？
@skyland84
这个就是对被Join的那个做分组
所以叫GroupJoin
如果只从他的语法上看，确实很难理解
请问用扩展方法如何left join? 查了很多地方也不见有说的.
@moosdau
来个例子吧
from d in data
join myReport in report
on d.OrderId equals myReport.OrderId into tmp
from r in tmp.DefaultIfEmpty()
@webabcd
谢谢回复, 可是我问的是用"扩展方法"如何left join, 就是函数式的语法.
@moosdau
嗯。。。
来个例子
Schedules.GroupJoin(Products, s=>s.ScheduleId, p=>p.ProductID, (s,g)=> new {s.ScheduleId, tmp = g.DefaultIfEmpty()}).Select(x => new {x.ScheduleId, x.tmp.First().Title})
@webabcd
谢谢.
可是在Linq to Sql中这个语法产生的sql语句并不是期望的.
例如:
var rs = db.BasicJob.GroupJoin(
db.JobType,
p => p.JobTypeID,
p2 => p2.ID,
(p, p2) =>new
{
p.Name,
jt= p2.DefaultIfEmpty()
})
.Select(p=>new {
p.Name,
n2= p.jt.First().Name
})
.ToList();
产生的SQL语句是:
SELECT [t0].[Name], (
SELECT [t4].[Name]
FROM (
SELECT TOP (1) [t3].[Name]
FROM (
SELECT NULL AS [EMPTY]
) AS [t1]
LEFT OUTER JOIN (
SELECT [t2].[Name]
FROM [dbo].[JobType] AS [t2]
WHERE [t0].[JobTypeID] = [t2].[ID]
) AS [t3] ON 1=1
) AS [t4]
) AS [n2]
FROM [dbo].[BasicJob] AS [t0]
但是用from ...join...into 这样的语法产生的SQL语句是标准的LEFT JOIN .
@木只八刀
那就类似这样写
Schedules
.GroupJoin (
Products,
s => s.ScheduleId,
p => p.ProductID,
(s, g) =>
new
{
s = s,
g = g
}
)
.SelectMany (
temp0 => temp0.g.DefaultIfEmpty (),
(temp0, r) =>
new
{
ScheduleId = temp0.s.ScheduleId,
Title = r.Title
}
)
|