查询表达式实际上是由编译器“预处理”为“普通”的C#代码,接着以完全普通的方式进行编译。这种巧妙的发式将查询集合到了语言中,而无须把语义改得乱七八糟

LINQ的介绍
LINQ中的基础概念
降低两种数据模型之间的阻抗失配过程中,遇到的一个问题就是,通常会涉及创建另一个模型来作为桥梁
序列
它通过IEnumerable和IEnumerable<T>接口进行封装
序列和其他集合数据结构最大的区别:当你从序列读取数据的时候,通常不知道还有多少数据项等待读取,或者不能访问任意的数据项——只能是当前这个
序列是LINQ的基础,一个查询表达式涉及的序列:一开始总是存在至少一个序列,且通常在中间过程会转换为转换为其他序列,也可能和更多的序列连接在一起
序列是数据处理流模型的基础,让我们能够只在需要的时候才对数据进行获取处理
var adultNames=from person in people
                            where person.Age>=18
                            select person.Name;
延迟执行和流处理
LINQ的这个特点称为延长处理。在最终结果的第一元素被访问的时候,Select转换才会为它的第一个元素调用Where转换。而Where转化会访问列表中的第一个元素,检查这个谓词是否匹配,并把这个元素返回给Select,最后依次提取出名称作为结果返回。
返回另外一个序列的擦欧总称为延迟执行,返回但一值的运算使用立即执行
标准查询操作符
LINQ的标准查询操作符是一个转换的集合,具有明确的含义
选择元素
以数据源作为开始,以选择作为结束
声明一个数据序列的数据源:from element in source
element只是一个标识符,它前面可以放置一个类型名称
source是一个普通的表达式
 
select expression
select子句被称为投影
#region 11-1打印出所有用户的袖珍查询
var query = from user in SampleData.AllUsers
select user;
foreach (var user in query)
{
Console.WriteLine(user);
}
#endregion
编译器转译是查询表达式基础的转译
#region 11-2将11-1的查询表达式被转译为一个方法调用
var query = SampleData.AllUsers.Select(user => user);//编译器不要求Select必须为一个方法,或AllUsers必须为属性,只要转换后的代码可以编译就可以了
foreach (var user in query)
{
Console.WriteLine(user);
}
#endregion
在LINQ to Objects中只进行一种调用——任何时候,参数都是委托类型,编译器将用Lambda表达式作为实参,并尽量查找具有合适签名的方法。
语言规范给出了查询表达式模式的细节,必须实现所有查询表达式的查询表达式模式,才能正常工作,不过它并没有如你所期望的那样被定义为一个接口——它通过扩展方法,能够让LINQ应用于IEnumerable<T>这样的接口
编译器转译工作原理:它为Select和Where提供了伪实现,使Select成为一个普通实例方法,而使Where成为一个扩展方法,
#region 11-3编译器转译调用伪LINQ实现中的方法
static class Extensions
{
public static Dummy<T> Where<T>(this Dummy<T> dummy, Func<T, bool> predicate)//声明Where扩展方法
{
Console.WriteLine("Where called");
return dummy;
}
}
class Dummy<T>
{
public Dummy<U> Select<U>(Func<T, U> selector)//声明Select实例方法
{
Console.WriteLine("Select called");
return new Dummy<U>();
}
 
}
#endregion
#region 11-3
var source = new Dummy<string>();//创建用于查询的数据源
var query = from dummy in source
where dummy.ToString() == "Ignored"
select "Anything";//通过查询表达式来调用方法var query=source.where(dummy=>dummy.ToString()=="Ignored").Select(dummy=>"Anything")
#endregion
所有LINQ提供器都把数据显示为IEnumerable<T>或IQueryable<T>。转译不依赖于任何特定类型而仅仅依赖于方法名称和参数,这是一种鸭子类型的编译形式。和集合初始化程序使用了同样的方式:使用普通重载决策来查找公共方法调用Add,而不是使用包含特定签名的Add方法的接口。查询表达式进一步利用了这种思想——转译发生在编译过程初期,以便让编译器来挑选实例方法或扩展方法。甚至可以认为,转译是在一个独立的预处理引擎中工作
范围变量和重要的投影

上下文关键字很容易理解——它们明确告知编译器我们要对数据进行的处理
数据源表达式也仅仅是普通的C#表达式——在这个例子中是一个属性,不过也可以是一个简单的方法调用或变量
范围变量不像其他种类的变量,在某些方面,它根本就不是变量。它们只能用于查询表达式中,实际代表从一个表达式传递给另一个表达式的上下文信息。它们表达了特定序列中的一个元素,而且它们被用于编译器转译中,以便把其他表达式轻易的转译为Lambda表达式。
SampleData.AllUser.Select(user=>user)
Lambda表达式的左边——提供参数名称的部分来自于范围变量的声明,而右边来自于select子句
#region 11-4仅选择user对象名称的查询
IEnumerable<string> query = from user in SampleData.AllUsers
select user.Name;
foreach (string name in query)
{
Console.WriteLine(name);
}
#endregion
在将Lambda表达式转换为Func<TSource,TResult>的时候,类型推断也发生了作用。它首先根据SampleData.AllUsers的类型推断出TSource为User,这样就知道了Lambda表达式的参数类型,并因此将user.Name作为返回string类型的属性访问表达式,也就可以推断出TResult为string。这就是Lambda表达式允许使用隐式类型参数的原因,也就是会存在如此复杂的类型推断规则的原因:这些都是LINQ引擎的"齿轮"和"活塞"。
Cast,OfType和显示类型的范围变量
范围变量都可以是隐式类型
这两个操作符很相似:都可以处理任意非类型化序列(它们是非泛型IEnumerable类的扩展方法),并返回强类型的序列。Cast通过把每个元素都转换为目标类型来处理,而OfType首先进行一个测试,以跳过任何具有错误类型的元素
#region 11-5使用Cast和OfType来处理弱类型集合
ArrayList list = new ArrayList { "First", "Second", "Third" };
IEnumerable<string> strings = list.Cast<string>();
foreach (string item in strings)
{
Console.WriteLine(item);
}
list = new ArrayList { 1, "First", 'd', "dsds", 3 };
strings = list.OfType<string>();
foreach (string item in strings)
{
Console.WriteLine(item);
}
#endregion
两个操作符都对数据进行流处理,在获取元素的时候才对其进行转换
在你引入了具有显示类型的范围变量后,编译器就调用Cast来保证在查询表达式的剩余部分中使用的序列具有合适的类型
#region 11-6使用显示类型的范围变量来自动调节Cast
ArrayList list = new ArrayList { "First", "Second", "Third" };
var strings = from string entry in list
select entry.Substring(0, 3);//IEnumerable<string> strings = from entry in source.Cast<string>() select entry.Substring(0, 3);
foreach (string start in strings)
{
Console.WriteLine(start);
}
#endregion
编译器转译时改表达式调用了Cast方法,没有这个类型转换,根本就不能调用Select,因为该扩展方法只用于IEnumerable<T>,而不能用于IEnumerable。
重要概念:
  • LINQ以数据序列为基础,在任何可能的地方都进行流处理
  • 创建一个查询并不会执行它:大部分操作都是延迟执行
  • C#3的查询表达式包括一个把表达式转换为普通C#代码的预处理阶段,接着使用类型推断,重载,Lambda表达式等这些常规的规则来恰当的对转换后的代码进行编译
  • 在查询表达式中声明的变量的作用:它们仅仅是范围变量,通过它们你可以查询表达式内部一直的引用数据

对序列进行过滤和排序

它们是对编译器转换进行解释的最简单的方法之一,它们总是返回和输入同样类型的序列
使用where子句进行过滤
where 过滤表达式
编译器把这个子句转译为带有Lambda表达式的Where方法调用,它使用合适的范围变量作为这个Lambda表达式的参数,而以过滤表达式作为主体。过滤表达式当作进入数据流的每个元素的谓词,只有返回true的元素才能出现在结果序列中。使用多个where子句,会导致多个链接在一起的Where调用——只有满足所有的谓词的元素才能进入结果序列
#region 11-7使用多个where字句的查询表达式
User tim = SampleData.Users.TesterTim;
var query = from defect in SampleData.AllDefects
where defect.Status != Status.Closed
where defect.AssignedTo == tim
select defect.Summary;
 
foreach (var summary in query)
{
Console.WriteLine(summary);
}
#endregion
退化的查询表达式
如果我们的select子句什么都不做,只是返回同给定的序列的序列相同的序列。
编译器会删除所有对Select调用,当然,前提是在查询表达式中还有其他操作可执行时才这么做。
from defect in SampleData.AllDefects
select defect
这就是所谓的退化查询表达式。编译器会故意生成一个对Select方法的调用,即使它什么都没有做:
SampleData.AllDefects.Select(defact=>defect)
查询表达式的结果和数据源永远不会是同一个对象
使用orderby子句进行排序
#region 11-8按缺陷严重度的优先级从高到低的顺序排序
User tim = SampleData.Users.TesterTim;
var query = from defect in SampleData.AllDefects
where defect.Status != Status.Closed
where defect.AssignedTo == tim
orderby defect.Severity descending
select defect;
foreach (var defect in query)
{
Console.WriteLine("{0},{1}", defect.Severity, defect.Summary);
}
#endregion
#region 11-9先按严重度排序,而后按最后修改时间排序
User tim = SampleData.Users.TesterTim;
var query = from defect in SampleData.AllDefects
where defect.Status != Status.Closed
where defect.AssignedTo == tim
orderby defect.Severity descending, defect.LastModified
select defect;
foreach (var defect in query)
{
Console.WriteLine("{0},{1}({2:d})", defect.Severity, defect.Summary, defect.LastModified);
}
#endregion
上下文关键字orderby,后面跟一个或多个排序规则。一个排序规则就是一个表达式,后面可以紧跟ascending或descending关键字
OrderBy假设它对排序规则起决定作用,而ThenBy可理解为对之前的一个或多个排序规则起辅助作用。ThenBy只是定义为IOrderdEnumerable<T>扩展方法,这是一个由OrderBy返回的类型
能使用多个orderby子句,每个都会以它自己的OrderBy或OrderByDescending子句作为开始,最后一个才会真正“获胜”
let子句和透明标识符
用let来进行中间计算
let子句只不过引入一个新的范围变量,它的值是基于其他范围变量
let 标识符=表达式
#region 11-10在不使用let子句的情况下,按用户名称长度来排序
var query = from user in SampleData.AllUsers//两次使用了Length
orderby user.Name.Length
select user.Name;
foreach (var name in query)
{
Console.WriteLine("{0}:{1}", name.Length, name);
}
#endregion
#region 11-11使用let子句来消除冗余的计算
var query = from user in SampleData.AllUsers
let length = user.Name.Length//引入length范围变量
orderby length
select new { Name = user.Name, Length = length };
foreach (var name in query)
{
Console.WriteLine("{0}:{1}", name.Name, name.Length);
}
#endregion
连接
使用join子句的内连接
内连接涉及两个序列,一个键选择器表达式应用于第一个序列的每个元素,另一个键选择器应用于第2个序列的每个元素,连接的结果是一个包含所有配对的序列,配对的规则是第一个元素的键与第二个元素的键相同
两个键选择器表达式必须有相同的键类型
#region 11-12根据项目把缺陷和通知订阅连接在一起
var query = from defect in SampleData.AllDefects
join subscription in SampleData.AllSubscriptions
on defect.Project equals subscription.Project
select new { defect.Summary, subscription.EmailAddress };
foreach (var entry in query)
{
Console.WriteLine("{0}:{1}", entry.EmailAddress, entry.Summary);
}
#endregion
在LINQ to Objects的实现中,返回条目的顺序为:先返回使用左边序列中第一个元素的所有成对数据能被返回,接着返回使用左边序列中第二个元素的所有成对数据,以此类推。右边序列被缓存处理,不过左边序列仍然进行流处理,所有如果打算把一个巨大的序列连接到一个极小的序列上,应尽可能把小序列作为右边序列。
使用join....into子句进行分组连接
分组连接结果中的每个元素由左边序列的某个元素和右边序列的所有匹配元素的序列组成。后者用一个新的范围变量表示,该变量由join子句中into后面的标识符指定
#region 11-13使用分组连接把缺陷的订阅连接到一起
var query = from defect in SampleData.AllDefects
join subscription in SampleData.AllSubscriptions
on defect.Project equals subscription.Project
into gtoupedSubscription
select new { Defece = defect, Subscription = gtoupedSubscription };
foreach (var enrty in query)
{
Console.WriteLine(enrty.Defece.Summary);
foreach (var subscription in enrty.Subscription)
{
Console.WriteLine("{0}", subscription.EmailAddress);
}
}
#endregion
使用多个from子句进行交叉连接和合并序列
交叉连接不在序列之间执行任何匹配操作:结果包含了所有可能的元素对。它们可以简单的使用两个(或多个)from子句实现。涉及多个from子句时,其实可认为是在前面两个from子句上执行交叉连接,接着把结果序列和下一个from子句再次进行交叉连接。每个额外的from子句都通过透明标识符添加自己的范围变量
#region 11-15用户和项目的交叉连接
var query = from user in SampleData.AllUsers
from project in SampleData.AllProjects
select new { User = user, Project = project };
foreach (var pair in query)
{
Console.WriteLine("{0}/{1}", pair.User.Name, pair.Project.Name);
}
#endregion
它就像多表查询的笛卡儿积。在任意特定时刻使用的右边序列依赖于左边序列的“当前”值。也就是说,左边序列中的每个元素都用于来生成右边的一个序列,然后左边这个元素与右边新生成序列的每个元素都组成一对
#region 11-16右边序列依赖于左边元素的交叉连接
var query = from left in Enumerable.Range(1, 4)
from right in Enumerable.Range(11, left)
select new { Left = left, Right = right };
foreach (var pair in query)
{
Console.WriteLine("Left={0};Rigth={1}", pair.Left, pair.Right);
}
#endregion
分组和延续
使用group....by子句进行分组
要做查询表达式中队序列进行分组,只需要使用group...by子句
group projection by grouping
改子句和select子句一样,出现在查询表达式末尾
 grouping表达式通过其键来决定序列如何分组。整个结果是一个序列,序列中的每个元素本身就是投影后元素的序列,还具有一个key属性,即用于分组的键。这样的组合封装在IGrouping<TKey,TElement>接口中的,还扩展了IEnumerable<TElement>
#region 11-17用分配来分组缺陷——无比简单的投影
var query = from defect in SampleData.AllDefects
where defect.AssignedTo != null//过滤未分配的缺陷
group defect by defect.AssignedTo;//用分配者来分组
foreach (var entry in query)
{
Console.WriteLine(entry.Key.Name);
foreach (var defect in entry)
{
Console.WriteLine("({0}) {1}", defect.Severity, defect.Summary);
}
Console.WriteLine();
}
#endregion
分组无法对结果进行流处理,它会对每个元素应用键选择和投影,并缓存被投影元素的分组序列
#region 11-18按分配者来分组缺陷——投影只保留概要信息
var query = from defect in SampleData.AllDefects
where defect.AssignedTo != null
group defect.Summary by defect.AssignedTo;
foreach (var entry in query)
{
Console.WriteLine(entry.Key.Name);
foreach (var summary in entry)
{
Console.WriteLine(" {0}", summary);
}
Console.WriteLine();
}
#endregion
查询延续
查询延续提供了一种方法,把一个查询表达式的结果用作另外一个查询表达式初始序列
它可以用于group....by和select字句上,语法对于两者是一样的——你只需要使用上下文关键字into,并为新的范围变量提供一个名称就可以了
#region 11-19使用另外一个投影来延续分组结果
var query = from defect in SampleData.AllDefects
where defect.AssignedTo != null
group defect by defect.AssignedTo into grouped
select new { Assignee = grouped.Key, Count = grouped.Count() };//在第二部分使用grouped范围变量,不过defect范围变量不在可用——它已经超出了它的作用域
foreach (var entry in query)
{
Console.WriteLine("{0}:{1}", entry.Assignee.Name, entry.Count);
}
#endregion
join....into不是延续      不能形成一个延续的结构,在分组连接中,你任然可以使用所以的早期范围变量,延续会清除之前的范围变量,只有在延续中声明的范围变量才能在供后续使用
#region 11-20在group和select子句之后的查询表达式延续
var query = from defect in SampleData.AllDefects
where defect.AssignedTo != null
group defect by defect.AssignedTo into grouped
select new
{
Assignee = grouped.Key,
Count = grouped.Count()
} into result
orderby result.Count descending
select result;
foreach (var entry in query)
{
Console.WriteLine("{0}:{1}", entry.Assignee.Name, entry.Count);
}
#endregion
在查询表达式和点标记之间作出选择
查询表达式在编译之前,先被转译成普通的C#。用普通的C#调用LINQ查询操作符来代替查询表达式,很多开发者称其为点标记
#region 只能用于点标记操作
var que = SampleData.AllUsers.Where(I1 => I1.Name.Length % 2 == 0).Select((I1, I2) => new { I1, I2 });
 
foreach (var entry in que)
{
Console.WriteLine(entry.I2);
}
Console.WriteLine();
foreach (var entry in que)
{
Console.WriteLine(entry.I1);
}
Console.ReadKey();
#endregion

 

查询表达式和LINQ to Objects的更多相关文章

  1. 十五、C# 使用查询表达式的LINQ

    使用查询表达式的LINQ   本章介绍了一种新的语法,查询表达式.   1.查询表达式概述 2.特点:投射  筛选  排序   Let  分组 3.作为方法调用   标准查询运算符所实现的查询在功能上 ...

  2. C#复习笔记(4)--C#3:革新写代码的方式(查询表达式和LINQ to object(下))

    查询表达式和LINQ to object(下) 接下来我们要研究的大部分都会涉及到透明标识符 let子句和透明标识符 let子句不过是引入了一个新的范围变量.他的值是基于其他范围变量的.let 标识符 ...

  3. 《C#本质论》读书笔记(15)使用查询表达式的LINQ

    15.1 查询表达式的概念 简单的查询表达式 private static void ShowContextualKeywords1() { IEnumerable<string> sel ...

  4. 2.1 LINQ的查询表达式

    在进行LINQ查询的编写之前,首先需要了解查询表达式.查询表达式是LINQ查询的基础,也是最常用的编写LINQ查询的方法. 查询表达式由查询关键字和对应的操作数组成的表达式整体.其中,查询关键字是常用 ...

  5. Linq之旅:Linq入门详解(Linq to Objects)

    示例代码下载:Linq之旅:Linq入门详解(Linq to Objects) 本博文详细介绍 .NET 3.5 中引入的重要功能:Language Integrated Query(LINQ,语言集 ...

  6. Linq之旅:Linq入门详解(Linq to Objects)【转】

    http://www.cnblogs.com/heyuquan/p/Linq-to-Objects.html Linq之旅:Linq入门详解(Linq to Objects) 示例代码下载:Linq之 ...

  7. Linq之旅:Linq入门详解(Linq to Objects)(转)

    http://www.cnblogs.com/heyuquan/p/Linq-to-Objects.html 示例代码下载:Linq之旅:Linq入门详解(Linq to Objects) 本博文详细 ...

  8. Linq查询表达式

    目录 1. 概述 2. from子句 3. where子句 4. select子句 5. group子句 6. into子句 7. 排序子句 8. let子句 9. join子句 10. 小结 1. ...

  9. Linq学习之旅——LINQ查询表达式

    1. 概述 2. from子句 3. where子句 4. select子句 5. group子句 6. into子句 7. 排序子句 8. let子句 9. join子句 10. 小结 1. 概述 ...

随机推荐

  1. Android Handler消息机制不完全解析

    1.Handler的作用 Android开发中,我们经常使用Handler进行页面的更新.例如我们需要在一个下载任务完成后,去更新我们的UI效果,因为AndroidUI操作不是线程安全的,也就意味着我 ...

  2. Java实现读取文章中重复出现的中文字符串

    在上个星期阿里巴巴一面的时候,最后面试官问我如何把一篇文章中重复出现的词或者句子找出来,当时太紧张,答的不是很好.今天有时间再来亲手实现一遍.其实说白了也就是字符串的处理,所以难度并不是很大. 以下是 ...

  3. servlet中的过滤器 国际化

    1. 过滤器 基本概念 过滤器是需要在xml中配置的. 为什么需用到过滤器? 项目开发中,经常会涉及到重复代码的实现! 注册 ----à Servlet [1. 设置编码] ----à  JSP 修改 ...

  4. 梳理一下web总的一些概念

    servlet中的类适合繁复翻看文档,熟悉各个类的常用方法,看一些经典的案例代码. ServletConfig 每个项目有多个servlet,每个servlet对应一个ServletCOnfigt对象 ...

  5. ArrayList去除重复元素(包括字符串和自定义对象)

    1.去除重复字符串 package com.online.msym; import java.util.ArrayList; import java.util.Iterator; @SuppressW ...

  6. java学习笔记 --- StringBuffer类

    1.定义:字符串缓冲区,即它是一个容器,容器中可以装很多字符.并且能够对其中的字符进行各种操作. StringBuffer的特点: 1.是一个字符串缓冲区,其实就是一个容器. 2.长度是可变,任意类型 ...

  7. Windows下检测文件名大小写是否匹配

    跨平台开发有一个众所周知,但因为只是偶尔受到困扰,一般人不会在意的问题,就是windows对文件名大小写不敏感,而其他平台对文件名大小写敏感.因此可能出现在windows平台开发时一切正常,但部署/打 ...

  8. POPTEST 150801 祝大家前途似锦

    POPTEST 150801 祝大家前途似锦   PT20150801学员不断在就业,同学们走好,远兵辛苦了!!!

  9. html实现 页面禁止右键 禁止复制 禁止图片拖动 禁止复制和剪切

    众所周知,一般的屏蔽的方法是用JS来编写的脚本,但是也可以直接通过修改网页属性的方法来屏蔽右键 禁止复制. 禁止右键 oncontextmenu="return false" 禁止 ...

  10. (转)Java并发编程:并发容器之ConcurrentHashMap

    下面这部分内容转载自: http://www.haogongju.net/art/2350374 JDK5中添加了新的concurrent包,相对同步容器而言,并发容器通过一些机制改进了并发性能.因为 ...