组内Linq培训记录

注： 由于该培训是在组内分享，先写成了Word，而word中的代码都以截图方式呈现了，而在博客园不能很方便的粘贴截图进来，所以我用插入代码的方式加进来，如果文中说“如下图”或“如下图代码”，那么就直接看下面的代码块就可以了。

Linq基本用法

1. 1.       前言：

要说Linq，要先做一些相关内容的铺垫。请稍安勿躁，下面马上开始。

 

1. 2.       集合和IEnumerable

集合包括数组、字典、列表等类型，这些类型都实现了IEnumerable（可枚举）接口。

1. 3.       隐式类型和var关键字

从.net 3.0开始，引入了隐式类型var，隐式类型的本地变量是强类型变量（就好像您已经声明该类型一样），但由编译器确定类型。 下面的两个声明在功能上是等效的：

double num = 1.0;

var num = 1.0;

由于var关键字声明的变量的类型是由编译器决定的，编译器判断的方法是在声明时，根据变量被赋值的类型来决定变量类型， 所以要求在声明时就进行赋值，否则编译器无法确定变量的类型， 所以如下写法是无效的：

var num;

日常开发中，可以都用var来声明变量，据说这样性能更优。

1. 4.       扩展方法

扩展方法使您能够向现有类型“添加”方法，而无需创建新的派生类型、重新编译或以其他方式修改原始类型。 扩展方法是一种特殊的静态方法，但可以像扩展类型上的实例方法一样进行调用。

a)         如何实现扩展方法

实现一个空的Cat类，并在该类外进行扩展，扩展一个Eat方法。扩展类CatExtend可以随便命名，但一定要是静态(Static)类，而且扩展的方法需要是静态方法，扩展方法的第一个参数的类型为（this关键字加要扩展的类）

 public class Cat
     {
     }
 
     public static class CatExtend
     {
         public static void Eat(this Animal c, string foodName)
         {
             Console.WriteLine("Animal eat {0}", foodName);
         }
     }

调用该方法的代码为：

 var myCat = new Cat();
 myCat.Eat('fish');
 
 // 输出 Cat eat fish

我们也可以扩展现有的类型，如Int32：

 public static class Int32Extend
 {
     public static int Pow(this Int32 i, int power)
     {
 
         var pow = Math.Pow(i, power);
         int result = Int32.TryParse(pow.ToString(), out result) ? result : ;
     }
 }

1. 5.       委托和Lambda表达式

在说Lambda之前，需要先简单提一下委托

a)         委托：

委托是一种定义方法签名的类型，可以与具有兼容签名的任何方法关联。您可以通过委托调用方法。委托用于将方法作为参数传递给其他方法。事件处理程序就是通过委托调用的方法。你可以用委托创建一个自定义方法，并将这个方法作为参数传递给其他方法。 这类似于JS中的回调函数。

b)         Lambda表达式：

“Lambda 表达式”是一个匿名函数，它可以包含表达式和语句，并且可用于创建委托或表达式目录树类型。

所有 Lambda 表达式都使用 Lambda 运算符 =>，该运算符读为“goes to”。该 Lambda 运算符的左边是输入参数（如果有），右边包含表达式或语句块。Lambda 表达式 x => x * x 读作“x goes to x times x”。可以将此表达式分配给委托类型，如下所示：

delegate int del(int i);

del myDelegate = x => x * x;

int j = myDelegate(5); //j = 25

其中的 x => x * x;  就是Lambda表达式。

Lambda表达式的标准形式为：

                      (input parameters) => expression

Input parameters为传入参数，当有多个时，用逗号分隔，可以不指定类型，编译器会自动判断，但也有些情况编译器无法自动判断，这是可以给参数指定类型。仅当传入参数个数为一个时，左边的括号可以忽略，否则必须写括号，如：

                      (x, y)=> x * y;

或

                      () => return 0;   // 当无传入参数时，也要写上括号。

Expression为该匿名函数的处理逻辑， 当该函数是直接通过一个语句返回结果，可以像上面的代码那么写，但如果需要一些逻辑处理语句，那么，可以像下面这么写：

(x, y) => { var i = x + 1; return i * y; }

具体可查看http://msdn.microsoft.com/zh-cn/library/bb397687(v=vs.90).aspx

c)         Func<>和Action<>

Func和Action都是函数类型，即上述的所有Lambda表达式都可赋值给相应的函数类型，以便之后调用。如：

 Func<int, int> fn1 = (x,y) => { var i = x+; return i * y; };
 Action<string> ac1 = (name) => {Console.WriteLine("Hello {0}.", name); };

Func和Action的区别在于，Func有一个返回值，而Action没有返回值。

根据上述代码，可看出Func和Action后的尖括号中，有逗号分隔的各种类型，这些类型表示的意思为：

l  Func: 最后一个类型为返回值的类型，之前的所有类型都是传入参数的类型，当只有一个类型时，为返回值的类型。

l  Action：全部类型都是传入参数的类型，也可以用不带尖括号的形式来声明，此时没传入参数。

Func和Action都能最多接受16个传入参数。

1. 6.       Linq表达式

Linq表达式接近于SQL的语法，书写起来比扩展方法具有更高的可读性，基本上熟悉SQL语法的程序员一看到Linq表达式，即使没用过，也能大概猜出语句的含义。这也是Linq的优势之一。

当引用了System.Linq命名空间后，就可以对所有可枚举类型使用Linq的方法和特性。包括Array,List,DataTable,各类型数组的对象等等。其中对DataTable等对象使用时，需要用AsEnumerable方法先转换成可枚举类型。

比较简单的Linq表达式：

 int[] numbers = new int[] { , , , , , ,  }；
 var numQuery =
     from num in numbers
     where ( num% ) ==
     select num;
 
 // return 0,2,4,6

其中numbers是数据源。一般linq的查询结果的类型都用var。

a)         和扩展方法的关系

Linq表达式在编译器中编译后，都会先变成扩展方法的样子，即上述例子在编译后会先变成：

Var numQuery = numbers.Where(num=>num%2==2).Select(num=> num);

b)         常用关键字及用法

以下大多数的关键字作用和SQL中的关键字或方法一一对应，作用一样。

i.              From、Select、Where

Linq表达式都需要用到From关键字。

var q = from num in numbers select num;

其中的num是对numbers集合中的每个元素自定义的别名。

  var q = from i in intArray
             where i >
             select i;

ii.              Count、Max、Min、Average、Sum、First

 q=  from i in intArray
        select i;
 
 Console.WriteLine("There are {0} numbers in intArray ", q.Count());
 Console.WriteLine("The max number is : {0} ", q.Max());
 Console.WriteLine("The min number is : {0} ", q.Min());
 Console.WriteLine("The average number is : {0} ", q.Average());
 Console.WriteLine("The sum of all numbers is : {0} ", q.Sum());
 Console.WriteLine("The first number is : {0} ", q.First());

iii.              Concat、Union、Distinct

Concat为直接拼接2个同类型数组，并返回。

Union为拼接拼接2个同类型数组，并过滤掉重复项，并返回结果。

Distinct为过滤一个数组中的重复项并返回结果。

示例，有如下数据源：

 var intArr1 = new int[] { , ,  };
 var intArr2 = new int[] { , ,  };
 var intArr3 = intArr1.Concat(intArr2);
 var intArr4 = intArr1.Union(intArr2);
 var intArr5 = intArr3.Distinct();

这么输出的话，结果如下：

 foreach(var i in intArr3)
 {
      Console.Write("{0},", i);
 }
 
 foreach(var i in intArr4)
 {
      Console.Write("{0},", i);
 }
 
 foreach(var i in intArr5)
 {
      Console.Write("{0},", i);
 }
 
 // intArr3:  1,2,3,1,2,4
 // intArr4:  1,2,3,4
 // intArr5:  1,2,3,4

iv.              Group、Group Join

Group的作用和SQL中的GROUP BY一样，GROUP JOIN和SQL中的JOIN一样。

示例： 假如有如下数据源：

 Person[] persons = new Person[]{
     new Person("Peter", sex.Male),
     new Person("Tom", sex.Male),
     new Person("Sue", sex.Female),
     new Person("Ken", sex.Male),
     new Person("Linda", sex.Female)
 };
 
 Sport[] sports = new Sport[]{
     new Sport(sex.Male, "Swim"),
     new Sport(sex.Male, "Tennis"),
     new Sport(sex.Female, "Draw")
 };

现在要按性别对persons数组进行group的话，可以这么写：

 var personQuery = from p in persons
                             group p by p.sex into g
                             select new { Sex = g.Key, Persons = g};

这里personQuery会得到两个集合，一个是性别为男的Person集合，一个是性别为女的Person集合。 Select new中的Sex，是性别， Persons是该性别的对象集合。

如果这样输出：

 foreach(var g in personQuery)
 {
     Console.WriteLine("{0} are:", g.Sex);
     foreach(Person pp in g.Persons)
     {
         Console.Write("{0},", pp.name);
     }
     Console.WriteLine();
 }

可以得到以下结果：

 /*
 Male are:
 Peter,Tom,Ken
 Female are:
 Sue,Linda
 */

v.              OrderBy、ThenBy

Order by作用和SQL中一样，可指定升序和降序，linq表达式的orderby支持多字段排序。如下：

 var orderByQ = from p in persons
                         order by p.sex descending, p.name descending
                         select p;
 
 Console.WriteLine("The person after order by sex and name");
 foreach( var p in orderByQ)
 {
     Console.Wirte("{0}," p.name);
 }
 Console.WirteLine();

输出为：

 /*
 The person after order by sex and name
 Sue,Linda,Tom,Peter,Ken,
 
 */

注：这里之所以Female会排在Male之前，因为性别是枚举类型，这里性别的排序不是根据Female和Male的拼写进行排序，而是根据其对应的枚举值进行排序。 Male的枚举值是1，Female是2，所以降序时，Female排在Male之前。

ThenBy主要用在扩展方法，上述查询如果要用扩展方法书写，应该这么写：

var orderByQ = persons.OrderByDescending(p => p.sex).ThenByDescending(p => p.name);

如果要多字段排序，要用ThenBy，否则只会按照最后一个OrderBy进行排序。

扩展方法中，有OrderBy、OrderByDescending、ThenBy、ThenByDescending，分别对应了升序和降序。

vi.              ToArray、ToList

这两个都属于扩展方法，可以将Linq查询结果转换成对应的类型或泛型。用起来非常简单，用上述的orderByQ的查询结果来转换，

 Person[] personArr = orderByQ.ToArray();
 List<Person> personList = orderByQ.ToList();