你的位置:首页 > ASP.net教程

[ASP.net教程][.net 面向对象编程基础] LINQ基础

[.net 面向对象编程基础] (19)  LINQ基础 

   上两节我们介绍了.net的数组、集合和泛型。我们说到,数组是从以前编程语言延伸过来的一种引用类型,采用事先定义长度分配存储区域的方式。而集合是.Net 版本初期的用于解决数据集检索方便而设计的,它比数组的优势除了检索方便之外,还可以在使用过程中自动分配存储区域,不需要事先定义大小。但是集合存在类型不安全以及频繁装箱、拆箱操作带来的性能问题。泛型是.net 2.0以后为了解决集合的缺陷而设计的,采用实例调用阶段再声明类型的方法,即解决了安全问题,也解决了效率问题。 

随着.net 3.5以后版本的发展,微软设计了LINQ,让我们检索更加方便,开发更加高效了。 

1.LINQ概念 

LINQ,语言集成查询(Language Integrated Query)是一组用于c#和Visual Basic语言的扩展。它允许编写C#或者Visual Basic代码以查询数据库相同的方式操作内存数据。 

以上是来自百度百科的定义。 

通过英文名描述,我们可以看出,它就是一种让开发者像查询数据库一样,去检索内存数据的方案。 

2.LINQ学习之前需要掌握以下知识点

看着有点多,但是都是学好LINQ的基础,我们说了LINQ就是像SQL语句一样操作内存数据,那么学习SQL要掌握表,字段,视图的基础概念,LINQ也一样。 

2.1 隐式类型 

之前我们定义变量时,需要指定一个类型,foreach遍历时,也要指定类型。隐式类型的出现我们不再需要做这个工作了,而使用var 定义就可以了,这点更像弱类型语言比如javascipt。但是.NET并不是弱类型语言,隐式类型的定义写法如下: 

var i=1;var b=”xyz”;var obj=new MyObj();

以上隐式类型等效于 

int i=1;string b=”xyz”;MyObj obj=new MyObj();

关于隐式类型的几点说明: 

A.有了隐式类型,可以编码中使用var定义任意类型变量 

B.隐式类型并不会影响程序性能,.NET会在编译时帮我们转换成具体的数据类型,因此我们必须声明隐式类型时赋值,不然.NET 不能判断具体转成什么类型而报错。

C.隐式类型var 使我们开发节约了不少时间。定义一个变量时,类型需要输两次,var 一下就搞定了。在foreach遍历的时候也可 以使用var来书写循环变量的类型。 

2.2匿名类型 

我们new一个对象,它里面的元素,类型可以不申明,而使用匿名方式。如下: 

//匿名类型var obj =new { str = "abc", Guid.Empty,myArray = new int[] { 1, 2, 3 } };Console.WriteLine(obj.str);Console.WriteLine(obj.Empty);Console.WriteLine(obj.myArray[0]);Console.ReadLine();

 运行结果如下:

我们看到new 一个对象后,自动为对象定义了属性,并为这些属性赋值,当把一个对象的属性拷贝到匿名对象中时,可以不用显示的指定属性的名字,这时原始属性的名字会被“拷贝”到匿名对象中.如下图:

 

自动创建了obj.Empty属性名。
如果你监视变量obj,你会发现,obj的类型是Anonymous Type类型的。
不要试图在创建匿名对象的方法外面去访问对象的属性!
这个特性在网站开发中,序列化和反序列化JSON对象时很有用。

2.3 自动属性

记得在“重构”一节中,说了属性的重构,只需要字段名上使用vs.net提供的“封装字段”,就为我们生成了相对应的属性,如下图:

 

(图1)


(图2)

(图3)

自.net 3.0以后,我们代码可以写的更简单了,代码如下: 

//自动属性class Flower {  public string Leaf{get;set;}  public string Name{get;set;}}

重构当然只是.net的辅助功能,对于自动属性小伙伴们肯定会担心这样写的效率,这点完全可以放心,跟var 隐式类型一样,.net在编译的时候,会帮我们写完整的,没有任何性能问题。

2.4 初始化器

对于一个对象的初始化,假如有以下两个对象:

//初始化器class Flower {  public string Leaf{get;set;}  public string Name{get;set;}}class Bear{  public Bear(string name){}  public string Name { get; set; }  public double Weight { get; set; }}

在3.0以前的版中,我们一般类似于如下写法:

//初始化器Flower flower = new Flower();flower.Leaf = "叶子";flower.Name = "棉花";

在3.0以后的版本中,我们可以这样写:

//.net 3.0以后对象初始化可以如下写法Flower flower2 = new Flower() { Name = "桃花", Leaf = "桃叶" };//构造函数带参数对象初始化Bear bear = new Bear("北极熊"){ Name="熊熊", Weight=300};//集合初始化var array = new List<char>() { 'a', 'b','c', 'd', 'e','f' };

我们可以看出,在写法上简洁好多了。特别是对泛型集合的赋值,相当简洁明了。

2.5 匿名方法

说到匿名方法,就是说在委托一个方法的时候,可以把方法写在委托声明的时候,简单说就是不用把方法单独写出来。在说这个之前,我们本来是要介绍一下委托的,但是下一节,我们会重点说明委托,在这里只需要了解匿名方法就可以了,下面看一个例子: 

 1 // 委托函数 2 Func<int, int, string> func1 = Adds; 3 // 匿名方法 4 Func<int, int, string> func2 = 5   delegate(int a, int b) 6   { 7     return a+"+"+b+"等于几?" + Environment.NewLine +(a+b).ToString(); 8   }; 9 // Lambda表达式10 Func<int, int, string> func3 =11   (a, b) => { return a + "+" + b + "等于几?" + Environment.NewLine + (a + b).ToString(); };12 13 // 调用Func委托14 string sum = func2(45, 36);15 16 Console.WriteLine(sum);17 Console.ReadLine();

//委托方法static string Adds(int a, int b){  return a + "+" + b + "等于几?" + Environment.NewLine + (a + b).ToString(); }

通过使用匿名方法,可以访问上下文中的变量,在方法本身不是很长的情况下,轻量级的写法,非常实用。

这点在下一节委托中具体说明,小伙伴在这里没看明白也没关系。 

2.6 扩展方法

1) 扩展方法声明在静态类中,定义为一个静态方法,其第一个参数需要使用this关键字标识,指示它所扩展的类型。

2) 扩展方法可以将方法写入最初没有提供该方法的类中。还可以把方法添加到实现某个接口的任何类中,这样多个类就可以使用相同的实现代码。(LINQ中,System.Linq.Queryable.cs和System.Linq.Enumerable.cs 正是对接口添加扩展方法)

3) 扩展方法虽定义为一个静态方法,但其调用时不必提供定义静态方法的类名,只需引入对应的命名空间,访问方式同实例方法。

4) 扩展方法不能访问它所扩展的类型的私有成员。

例子:

public static IEnumerable<TSource> MyWhere<TSource>(  this IEnumerable<TSource> source, Func<TSource, bool> predicate) {      foreach (TSource item in source)      {        if (predicate(item))          yield return item;      }}

 我们再看一下扩展方法的厉害的地方,要给一个类型增加行为,不一定要使用继承的方法实现,还可以这样写:

var a = "aaa";a.PrintString(); Console.ReadKey();

但通过我们上面的代码,就给string类型"扩展"了一个PrintString方法。

(1)先决条件

<1>扩展方法必须在一个非嵌套、非泛型的静态类中定义

<2>扩展方法必须是一个静态方法

<3>扩展方法至少要有一个参数

<4>第一个参数必须附加this关键字作为前缀

<5>第一个参数不能有其他修饰符(比如ref或者out)

<6>第一个参数不能是指针类型

(2)注意事项

<1>跟前面提到的几个特性一样,扩展方法只会增加编译器的工作,不会影响性能(用继承的方式为一个类型增加特性反而会影响性能)

 <2>如果原来的类中有一个方法,跟你的扩展方法一样(至少用起来是一样),那么你的扩展方法奖不会被调用,编译器也不会提示你

 <3>扩展方法太强大了,会影响架构、模式、可读性等等等等....

2.7 迭代器

(1)使用

我们每次针对集合类型编写foreach代码块,都是在使用迭代器

这些集合类型都实现了IEnumerable接口

都有一个GetEnumerator方法

但对于数组类型就不是这样

编译器把针对数组类型的foreach代码块

替换成了for代码块。

来看看List的类型签名: 

public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable

IEnumerable接口,只定义了一个方法就是:   

IEnumerator<T> GetEnumerator();

(2)迭代器的优点:

 假设我们需要遍历一个庞大的集合

 只要集合中的某一个元素满足条件

 就完成了任务

 你认为需要把这个庞大的集合全部加载到内存中来吗?

 当然不用(C#3.0之后就不用了)!

 来看看这段代码:         

static IEnumerable<int> GetIterator(){  Console.WriteLine("迭代器返回了1");  yield return 1;  Console.WriteLine("迭代器返回了2");  yield return 2;  Console.WriteLine("迭代器返回了3");  yield return 3;}

foreach (var i in GetIterator()){  if (i == 2)  {    break;  }  Console.WriteLine(i);}Console.ReadKey();

输出结果为:    

迭代器返回了11迭代器返回了2

大家可以看到:

当迭代器返回2之后,foreach就退出了

并没有输出“迭代器返回了3”

也就是说下面的工作没有做。

(3)yield 关键字

MSDN中的解释如下:

在迭代器块中用于向枚举数对象提供值或发出迭代结束信号。

也就是说,我们可以在生成迭代器的时候,来确定什么时候终结迭代逻辑

上面的代码可以改成如下形式:  

static IEnumerable<int> GetIterator(){  Console.WriteLine("迭代器返回了1");  yield return 1;  Console.WriteLine("迭代器返回了2");  yield break;  Console.WriteLine("迭代器返回了3");  yield return 3;}

(4)注意事项

<1>做foreach循环时多考虑线程安全性      

在foreach时不要试图对被遍历的集合进行remove和add等操作

任何集合,即使被标记为线程安全的,在foreach的时候,增加项和移除项的操作都会导致异常

<2>IEnumerable接口是LINQ特性的核心接口

只有实现了IEnumerable接口的集合

才能执行相关的LINQ操作,比如select,where等

关于LINQ的具体操作,下一节继承。

2.8 Lambda表达式

Lambda表达式只是用更简单的方式来书写匿名方法,从而彻底简化.NET委托类型的使用。  

Lambda表达式在C#中的写法是“arg-list => expr-body”,“=>”符号左边为表达式的参数列表,右边则是表达式体(body)。参数列表可以包含0到多个参数,参数之间使用逗号分割。

通过上面匿名方法的例子,我们可以看到,下面两段代码是等效的:

// 匿名方法Func<int, int, string> func2 =  delegate(int a, int b)  {    return a+"+"+b+"等于几?" + Environment.NewLine +(a+b).ToString();  };// Lambda表达式Func<int, int, string> func3 =  (a, b) => { return a + "+" + b + "等于几?" + Environment.NewLine + (a + b).ToString(); };

Lambda表达式基于数学中的λ(希腊第11个字母)演算得名,而“Lambda 表达式”(lambda expression)是指用一种简单的方法书写匿名方法。

3.要点:

A.LINQ,语言集成查询(Language Integrated Query)是一种语言扩展,让我们像查询数据库一样去操作内存数据(集合等).

B.匿名类型:使用new声明匿名类型时,不需指明类型,.NET 3.0以后版本,可以自动完成类型指定和指定属性名称

C.自动属性:.net 3.0 以后版本中,我们定义属性,只需要简单书写get;set;就可以了,.net在编译阶段会帮助我们完成书写,不会存在性能问题。

D.初始化器:在3.0以后版本中,可以更加简单的书写对象初始化,特别是对泛型集合的赋值,相当简洁明了。

E.匿名方法:在委托方法时,无需写明方法名称.使用匿名方法可以访问上下文中的变量,在方法代码较少的情况下,轻量级实现委托,非常实用。

F.扩展方法:可以在不使用继承的方式给一个类型增加行为

G.迭代器:在遍历一个庞大集合时,不需要将它全部加载于是内存中,只要满足条件就可以返回了。

H.Lambda表达式:Lambda表达式基于数学中的λ(希腊第11个字母)演算得名,而“Lambda 表达式”(lambda expression)是指用一种简单的方法书写匿名方法

备注:本文参考了博友们的一些文章,数目较多,不一一列举,在此表示感谢。

对于LINQ的使用我们下一节详细说明。

 

 ============================================================================================== 

返回目录 <如果对你有帮助,记得点一下推荐哦,有不明白的地方或写的不对的地方,请多交流> 

==============================================================================================