Linq学习笔记(第一部分)

本文分享自lliulun的30分钟linq教程，地址:http://www.cnblogs.com/liulun/archive/2013/02/26/2909985.html

一：与LINQ有关的语言特性

　　1.隐式类型

　　　　（1）源起

　　　　　　在隐式类型出现之前,

　　　　　　我们在声明一个变量的时候,

　　　　　　总是要为一个变量指定他的类型

　　　　　　甚至在foreach一个集合的时候，

　　　　　　也要为遍历的集合的元素，指定变量的类型

　　　　　　隐式类型的出现，

　　　　　　程序员就不用再做这个工作了。

　　　　（2）使用方法

　　　　 　　来看下面的代码：

var a = ; //int a = 1;
　　　　　　var b = "";//string b = "123";
　　　　　　var myObj = new MyObj();//MyObj myObj = new MyObj()

上面的每行代码，与每行代码后面的注释，起到的作用是完全一样的

　　　　　　也就是说，在声明一个变量（并且同时给它赋值）的时候，完全不用指定变量的类型，只要一个var就解决问题了

　　　　（3）你担心这样写会降低性能吗？

　　　　　　我可以负责任的告诉你，这样写不会影响性能！

　　　　　　上面的代码和注释里的代码，编译后产生的IL代码（中间语言代码）是完全一样的

　　　　　　（编译器根据变量的值，推导出变量的类型，才产生的IL代码）　　　　　　

　　　　（4）这个关键字的好处：

　　　　　　你不用在声明一个变量并给这个变量赋值的时候，写两次变量类型

　　　　　　（这一点真的为开发者节省了很多时间）

　　　　　　在foreach一个集合的时候，可以使用var关键字来代替书写循环变量的类型

　　　　 （5）注意事项

　　　　　　你不能用var关键字声明一个变量而不给它赋值

　　　　　　因为编译器无法推导出你这个变量是什么类型的。

　　2.匿名类型

　　　　(1)源起

　　　　　　创建一个对象，一定要先定义这个对象的类型吗？

　　　　　　不一定的！

　　　　　　来看看这段代码

　　　　（2）使用　

var obj = new {Guid.Empty, myTitle = "匿名类型", myOtherParam = new int[] { , , ,  } };
         Console.WriteLine(obj.Empty);//另一个对象的属性名字，被原封不动的拷贝到匿名对象中来了。
         Console.WriteLine(obj.myTitle);
         Console.ReadKey();

new关键字之后就直接为对象定义了属性，并且为这些属性赋值

　　　　　　而且，对象创建出来之后，在创建对象的方法中，还可以畅通无阻的访问对象的属性

　　　　　　当把一个对象的属性拷贝到匿名对象中时，可以不用显示的指定属性的名字，这时原始属性的名字会被“拷贝”到匿名对象中

　　　　（3）注意　　　　

　　　　　　如果你监视变量obj，你会发现，obj的类型是Anonymous Type类型的

　　　　　　不要试图在创建匿名对象的方法外面去访问对象的属性！

　　　　（4）优点

　　　　　　这个特性在网站开发中，序列化和反序列化JSON对象时很有用

　　3.自动属性

　　　　（1）源起

　　　　　　为一个类型定义属性，我们一般都写如下的代码：

public class MyObj2
    　　　　{
        　　　　private Guid _id;
        　　　　private string _Title;
        　　　　public Guid id
        　　　　{
            　　　　get { return _id; }
            　　　　set { _id = value; }
        　　　　}
        　　　　public string Title
        　　　　{
            　　　　get { return _Title; }
            　　　　set { _Title = value; }
        　　　　}
    　　　　}

但很多时候，这些私有变量对我们一点用处也没有，比如对象关系映射中的实体类。

　　　　　　自C#3.0引入了自动实现的属性，

　　　　　　以上代码可以写成如下形式：

　　　　（2）使用

 public class MyObj
     　　　　{
         　　　　public Guid id { get; set; }
         　　　　public string Title { get; set; }
     　　　　}

这个特性也和var关键字一样，是编译器帮我们做了工作，不会影响性能的

　　4.初始化器

　　　　（1）源起

　　　　　　我们创建一个对象并给对象的属性赋值，代码一般写成下面的样子

 var myObj = new MyObj();
             myObj.id = Guid.NewGuid();
             myObj.Title = "allen";

自C#3.0引入了对象初始化器，

　　　　　　代码可以写成如下的样子

　　　　（2）使用

 var myObj1 = new MyObj() { id = Guid.NewGuid(), Title = "allen" };

如果一个对象是有参数的构造函数

　　　　　　那么代码看起来就像这样

 　var myObj1 = new MyObj ("allen") { id = Guid.NewGuid(), Title = "allen" };

集合初始化器的样例代码如下：

 var arr = new List<int>() { , , , , ,  };

（3）优点

　　　　　　我个人认为：这个特性不是那么amazing，

　　　　　　这跟我的编码习惯有关，集合初始化器也就罢了，

　　　　　　真的不习惯用对象初始化器初始化一个对象！

　　5.委托

　　　　（1）使用

　　　　　　我们先来看一个简单的委托代码

 delegate Boolean moreOrlessDelgate(int item);
     　　　　class Program
     　　　　{
         　　　　static void Main(string[] args)
         　　　　{
             　　　　var arr = new List<int>() { , , , , , ,, };
             　　　　var d1 = new moreOrlessDelgate(More);
             　　　　Print(arr, d1);
             　　　　Console.WriteLine("OK");

             　　　　var d2 = new moreOrlessDelgate(Less);
             　　　　Print(arr, d2);
             　　　　Console.WriteLine("OK");
             　　　　Console.ReadKey();

         　　　　}
         　　　　static void Print(List<int> arr,moreOrlessDelgate dl)
         　　　　{
             　　　　foreach (var item in arr)
             　　　　{
                 　　　　if (dl(item))
                 　　　　{
                     　　　　Console.WriteLine(item);
                 　　　　}
             　　　　}
         　　　　}
         　　　　static bool More(int item)
         　　　　{
             　　　　if (item > )
             　　　　{
                 　　　　return true;
             　　　　}
             　　　　return false;
         　　　　}
         　　　　static bool Less(int item)
         　　　　{
             　　　　if (item < )
             　　　　{
                 　　　　return true;
             　　　　}
             　　　　return false;
         　　　　}
     　　　　}

这段代码中

　　　　　　<1>首先定义了一个委托类型

　　　　　　　　delegate Boolean moreOrlessDelgate(int item);

　　　　　　　　你看到了，委托和类是一个级别的，确实是这样：委托是一种类型

　　　　　　　　和class标志的类型不一样，这种类型代表某一类方法。

　　　　　　　　这一句代码的意思是：moreOrlessDelgate这个类型代表返回值为布尔类型，输入参数为整形的方法

　　　　　　<2>有类型就会有类型的实例　　

　　　　　　　　var d1 = new moreOrlessDelgate(More);  　　　

　　　　　　　　var d2 = new moreOrlessDelgate(Less);

　　　　　　　　这两句就是创建moreOrlessDelgate类型实例的代码，

　　　　　　　　它们的输入参数是两个方法

　　　　　　<3>有了类型的实例，就会有操作实例的代码　　　

　　　　　　　　Print(arr, d1);

　　　　　　　　Print(arr, d2);

　　　　　　　　我们把前面两个实例传递给了Print方法

　　　　　　　　这个方法的第二个参数就是moreOrlessDelgate类型的

　　　　　　　　在Print方法内用如下代码，调用委托类型实例所指向的方法

　　　　　　　　dl(item)

　　6.泛型

　　　　(1)为什么要有泛型

　　　　　　假设你是一个方法的设计者，

　　　　　　这个方法有一个传入参数，有一个返回值。

　　　　　　但你并不知道这个参数和返回值是什么类型的，

　　　　　　如果没有泛型，你可能把参数和返回值的类型都设定为Object了

　　　　　　那时，你心里肯定在想：反正一切都是对象，一切的基类都是Object

　　　　　　没错！你是对的！

　　　　　　这个方法的消费者，会把他的对象传进来（有可能会做一次装箱操作）

　　　　　　并且得到一个Object的返回值，他再把这个返回值强制类型转化为他需要的类型

　　　　　　除了装箱和类型转化时的性能损耗外，代码工作的很好！

　　　　　　那么这些新能损耗能避免掉吗？

　　　　　　有泛型之后就可以了！

　　　　（2）使用

　　　　　　<1>使用简单的泛型

　　　　　　　　先来看下面的代码：

 　　var intList = new List<int>() { ,,};
             　　intList.Add();
             　　intList.Insert(, );
             　　foreach (var item in intList)
             　　{
                 　　Console.WriteLine(item);
             　　}
             　　Console.ReadKey();

在上面这段代码中我们声明了一个存储int类型的List容器

　　　　　　　　并循环打印出了容器里的值

　　　　　　　　注意：如果这里使用Hashtable、Queue或者Stack等非泛型的容器

　　　　　　　　就会导致装箱操作，损耗性能。因为这些容器只能存储Object类型的数据

　　　　　　<2>泛型类型

　　　　　　　　List<T>、Dictionary<TKey, TValue>等泛型类型都是.net类库定义好并提供给我们使用的

　　　　　　　　但在实际开发中，我们也经常需要定义自己的泛型类型

　　　　　　　　来看下面的代码：

　　　　　　public static class SomethingFactory<T>
    　　　　　　{
        　　　　　　public static T InitInstance(T inObj)
        　　　　　　{
            　　　　　　if (false)//你的判断条件
            　　　　　　{
                　　　　　　//do what you want...
                　　　　　　return inObj;
            　　　　　　}
            　　　　　　return default(T);
        　　　　　　}
    　　　　　　}

这段代码的消费者如下：

　var a1 = SomethingFactory<int>.InitInstance();
            　　Console.WriteLine(a1);
            　　Console.ReadKey();

　输出的结果为0

　　　　　　　　这就是一个自定义的静态泛型类型，

　　　　　　　　此类型中的静态方法InitInstance对传入的参数做了一个判断

　　　　　　　　如果条件成立，则对传入参数进行操作之后并把它返回

　　　　　　　　如果条件不成立，则返回一个空值

　　　　　　　　注意：

　　　　　　　　　　[1]

　　　　　　　　　　　　传入参数必须为指定的类型，

　　　　　　　　　　　　因为我们在使用这个泛型类型的时候，已经规定好它能接收什么类型的参数

　　　　　　　　　　　　但在设计这个泛型的时候，我们并不知道使用者将传递什么类型的参数进来

　　　　　　　　　　[2]

　　　　　　　　　　　　如果你想返回T类型的空值，那么请用default(T)这种形式

　　　　　　　　　　　　因为你不知道T是值类型还是引用类型，所以别擅自用null

　　　　　　<3>泛型约束

　　　　　　　　很多时候我们不希望使用者太过自由

　　　　　　　　我们希望他们在使用我们设计的泛型类型时

　　　　　　　　不要很随意的传入任何类型

　　　　　　　　对于泛型类型的设计者来说，要求使用者传入指定的类型是很有必要的

　　　　　　　　因为我们只有知道他传入了什么东西，才方便对这个东西做操作

　　　　　　　　让我们来给上面设计的泛型类型加一个泛型约束

　　　　　　　　代码如下：　　　　　　　　

　　　　　　　　　　public static class SomethingFactory<T> where T:MyObj

　　　　　　　　这样在使用SomethingFactory的时候就只能传入MyObj类型或MyObj的派生类型啦

　　　　　　　　注意：

　　　　　　　　　　还可以写成这样

　　　　　　　　　　where T:MyObj,new()

　　　　　　　　　　来约束传入的类型必须有一个构造函数。　　　　　　　　

　　　　（3）泛型的好处

　　　　　　<1>算法的重用

　　　　　　　　想想看：list类型的排序算法，对所有类型的list集合都是有用的

　　　　　　<2>类型安全

　　　　　　<3>提升性能

　　　　　　　　没有类型转化了，一方面保证类型安全，另一方面保证性能提升

　　　　　　<4>可读性更好

　　　　　　　　这一点就不解释了

　　7.泛型委托

　　　　（1）源起

　　　　　　委托需要定义delgate类型

　　　　　　使用起来颇多不便

　　　　　　而且委托本就代表某一类方法

　　　　　　开发人员经常使用的委托基本可以归为三类，

　　　　　　哪三类呢？

　　　　　　请看下面：

　　　　（2）使用

　　　　　　<1>Predicate泛型委托

　　　　　　　　把上面例子中d1和d2赋值的两行代码改为如下：　　　　

            　　//var d1 = new moreOrlessDelgate(More);
            　　var d1 = new Predicate<int>(More);

            　　//var d2 = new moreOrlessDelgate(Less);
            　　var d2 = new Predicate<int>(Less);

　　　　　　　　把Print方法的方法签名改为如下：　　　　

        　　　　//static void Print(List<int> arr, moreOrlessDelgate<int> dl)
        　　　　static void Print(List<int> arr, Predicate<int> dl)

　　　　　　　　然后再运行方法，控制台输出的结果和原来的结果是一模一样的。

　　　　　　　　那么Predicate到底是什么呢？

　　　　　　　　来看看他的定义：

 　　　　　　// 摘要:
     　　　　　　//     表示定义一组条件并确定指定对象是否符合这些条件的方法。
     　　　　　　//
     　　　　　　// 参数:
     　　　　　　//   obj:
     　　　　　　//     要按照由此委托表示的方法中定义的条件进行比较的对象。
     　　　　　　//
     　　　　　　// 类型参数:
     　　　　　　//   T:
     　　　　　　//     要比较的对象的类型。
     　　　　　　//
     　　　　　　// 返回结果:
     　　　　　　//     如果 obj 符合由此委托表示的方法中定义的条件，则为 true；否则为 false。
     　　　　　　public delegate bool Predicate<in T>(T obj);

看到这个定义，我们大致明白了。

　　　　　　　　.net为我们定义了一个委托，

　　　　　　　　这个委托表示的方法需要传入一个T类型的参数，并且需要返回一个bool类型的返回值

　　　　　　　　有了它，我们就不用再定义moreOrlessDelgate委托了，

　　　　　　　　而且，我们定义的moreOrlessDelgate只能搞int类型的参数，

　　　　　　　　Predicate却不一样，它可以搞任意类型的参数

　　　　　　　　但它规定的还是太死了，它必须有一个返回值，而且必须是布尔类型的，同时，它必须有一个输入参数

　　　　　　　　除了Predicate泛型委托，.net还为我们定义了Action和Func两个泛型委托

　　　　　　<2>Action泛型委托

　　　　　　　　Action泛型委托限制的就不那么死了，

　　　　　　　　他代表了一类方法：

　　　　　　　　可以有0个到16个输入参数，

　　　　　　　　输入参数的类型是不确定的，

　　　　　　　　但不能有返回值，

　　　　　　　　来看个例子：　　　　　　

            　　var d3 = new Action(noParamNoReturnAction);
            　　var d4 = new Action<int, string>(twoParamNoReturnAction);

　　　　　　　　注意：尖括号中int和string为方法的输入参数

 　　　　static void noParamNoReturnAction()
         　　　　{
             　　　　//do what you want
         　　　　}
         　　　　static void twoParamNoReturnAction(int a, string b)
         　　　　{
             　　　　//do what you want
         　　　　}

<3>Func泛型委托

　　　　　　　　为了弥补Action泛型委托，不能返回值的不足

　　　　　　　　.net提供了Func泛型委托，

　　　　　　　　相同的是它也是最多0到16个输入参数，参数类型由使用者确定

　　　　　　　　不同的是它规定要有一个返回值，返回值的类型也由使用者确定

　　　　　　　　如下示例：　　　　　　

　　　　　　　　　　var d5 = new Func<int, string>(oneParamOneReturnFunc);

　　　　　　　　注意：string类型（最后一个泛型类型）是方法的返回值类型

        　　　　static string oneParamOneReturnFunc(int a)
        　　　　{
            　　　　//do what you want
            　　　　return string.Empty;
        　　　　}