Linq学习笔记(第一部分)

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

一:与LINQ有关的语言特性

  1.隐式类型

    (1)源起

      在隐式类型出现之前,

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

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

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

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

      隐式类型的出现,

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

    (2)使用方法

       来看下面的代码:

var a = 1; //int a = 1;
      var b = "123";//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[] { 1, 2, 3, 4 } };
         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)使用

              

1 public class MyObj
2         {
3             public Guid id { get; set; }
4             public string Title { get; set; }
5         }

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

  4.初始化器

    (1)源起

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

            

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

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

      代码可以写成如下的样子

    (2)使用

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

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

      那么代码看起来就像这样

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

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

1 var arr = new List<int>() { 1, 2, 3, 4, 5, 6 };

(3)优点

      我个人认为:这个特性不是那么amazing,

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

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

  5.委托

    (1)使用

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

        

 1 delegate Boolean moreOrlessDelgate(int item);
 2         class Program
 3         {
 4             static void Main(string[] args)
 5             {
 6                 var arr = new List<int>() { 1, 2, 3, 4, 5, 6,7,8 };
 7                 var d1 = new moreOrlessDelgate(More);            
 8                 Print(arr, d1);
 9                 Console.WriteLine("OK");
10 
11                 var d2 = new moreOrlessDelgate(Less);
12                 Print(arr, d2);
13                 Console.WriteLine("OK");
14                 Console.ReadKey();
15 
16             }
17             static void Print(List<int> arr,moreOrlessDelgate dl)
18             {
19                 foreach (var item in arr)
20                 {
21                     if (dl(item))
22                     {
23                         Console.WriteLine(item);
24                     }
25                 }
26             }
27             static bool More(int item)
28             {
29                 if (item > 3)
30                 { 
31                     return true; 
32                 }
33                 return false;
34             }
35             static bool Less(int item)
36             {
37                 if (item < 3)
38                 {
39                     return true;
40                 }
41                 return false;
42             }
43         }

           这段代码中

      <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>使用简单的泛型

        先来看下面的代码:

1   var intList = new List<int>() { 1,2,3};
2               intList.Add(4);
3               intList.Insert(0, 5);
4               foreach (var item in intList)
5               {
6                   Console.WriteLine(item);
7               }
8               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(12);
              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到底是什么呢?

        来看看他的定义:

 

 1       // 摘要:
 2           //     表示定义一组条件并确定指定对象是否符合这些条件的方法。
 3           //
 4           // 参数:
 5           //   obj:
 6           //     要按照由此委托表示的方法中定义的条件进行比较的对象。
 7           //
 8           // 类型参数:
 9           //   T:
10           //     要比较的对象的类型。
11           //
12           // 返回结果:
13           //     如果 obj 符合由此委托表示的方法中定义的条件,则为 true;否则为 false。
14           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为方法的输入参数

 

1     static void noParamNoReturnAction()
2             {
3                 //do what you want
4             }
5             static void twoParamNoReturnAction(int a, string b)
6             {
7                 //do what you want
8             }

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

 

posted @ 2014-11-07 09:35  shzhq  阅读(206)  评论(0编辑  收藏  举报