Linq本质论(1)

本篇blog是我在深圳.Net俱乐部12月活动的讲座的内容，现在整理出来，以飨读者。

本文的目的是帮助大家搞清楚C#3.0里面的Linq查询表达式的来龙去脉，搞清楚以后对C#3.0的新特性基本上也就了然于胸了。建议大家看完Linq查询后再看各个语法新特性对Linq的意义，这样会更加有帮助一些。

1、自动属性。

class Class
{
    //C#2.0 属性
    //private int _id;
    //public int ID
    //{
    //    get {
    //        return _id;
    //    }

    //    set
    //    {
    //        _id = value;
    //    }
    //}

    //C#3.0 属性可以给get set加访问修饰符
    public int ID { get; private set; }
    public string Name { get; set; }
    public Class(int id)
    {
        //加了private之后的属性只能在类的内部访问
        this.ID = id;
    }
}

本质：和原来的属性没啥两样，简化了语法而已。

对Linq的意义：无。

2、初始化器。

private static void Initializer()
{
    //C#2.0 对象初始化
    //Class c = new Class(1);
    //c.Name = "终极一班";
    //C#3.0 对象初始化器
    Class c = new Class(1) { Name = "终极一班" };
    //C#2.0 集合初始化
    //ClassCollection list = new ClassCollection();
    //list.Add(c);
    //C#3.0 集合初始化器
    ClassCollection list = new ClassCollection
    {
        new Class(1) { Name="终极一班"},
        new Class(2){Name="终极二班"}
    };
    foreach (Class item in list)
    {
        Console.WriteLine(item.ID + " " + item.Name);

}
}

相关的工厂方法:

static ClassCollection GetClasses()
{
    return new ClassCollection{
    new Class(1){ Name = "终极一班"},
    new Class(2){ Name = "终极二班"},
    };
}

1)现在需求发生了变化,需要上面的红色部分需要发生变化,也就是说我们希望这个查询条件可以在我们调用Filter方法的时候动态的指定,这时候我们可以把这个变化封装成一个接口,当然还可以封装成一个委托,这是.net的非常好用的独有特性,委托的最直接的作用可以把一个具体的方法引用封装成一个变量传递。好，开始变形!

delegate bool FilterHandler(Class c); //注意这个要放到namespace下面，不要放到Program类里面

public static ClassCollection Filter(this ClassCollection classes,FilterHandler f)
{
    var newlist = new ClassCollection();
    foreach (var item in classes)
    {
        if (f(item))

        {
            newlist.Add(item);
        }
    }
    return newlist;
}

static bool F(Class c)
{
return c.Name == "终极一班";
}

private static void LambdaLinq()
       {
           var classes = GetClasses();
           // C#1.0 使用委托封装过滤条件
           FilterHandler f=new FilterHandler(F);
          var result = classes.Filter(f);
          foreach (var item in result)
         {
            Console.WriteLine(item.ID+ " " + item.Name);
         }

}

我们声明了一个委托FilterHandler，只要满足这个委托的方法我们都可以传递给Filter方法，这样就实现了动态的改变查询条件的目的，F方法内部可以是任意的查询条件比如return c.Name != "终极一班";同时我们不需要改变Filter方法内部稳定的部分。

2）c#2.0里面也支持直接把一个方法传给一个委托，但本质上也是编译器把方法转换成了一个委托，例如上面：

private static void LambdaLinq()
       {
           var classes = GetClasses();
           // C#2.0 直接传递方法
          var result = classes.Filter(F);
          foreach (var item in result)
         {
            Console.WriteLine(item.ID+ " " + item.Name);
         }

}

3）C#2.0里面有个新特性，叫匿名方法，我们可以直接传递匿名方法：

private static void LambdaLinq()
       {
           var classes = GetClasses();
           // C#2.0 传递匿名方法
          var result = classes.Filter(delegate(Class c) { return c.Name == "终极一班"; });
          foreach (var item in result)
         {
            Console.WriteLine(item.ID+ " " + item.Name);
         }

}

好，变形到这里，我们发现这个匿名其实不仅仅可以给我们带来不用给方法命名的好处，在这个方法内部我们还可以使用外部上下文环境的变量成员，这个特性也叫"闭包（Closure）"，JavaScript也支持这个特性，比如：

private static void LambdaLinq()
{
var classes = GetClasses();

string className = "终极一班";
// C#2.0 传递匿名方法

           var result = classes.Filter(delegate(Class c) { return c.Name == className; });
         foreach (var item in result)
         {
            Console.WriteLine(item.ID+ " " + item.Name);
         }

}

4)大家发现没有，上面的语法还是有点拖沓，伟大的Microsoft又给我们提供了一种更简洁的写法（我怎么说了个"又"呢？^_^），这也就是我们所说的Lambda表达式了：

private static void LambdaLinq()
{
var classes = GetClasses();

string className = "终极一班";

          //4 C#3.0 Lambda表达式
          var result = classes.Filter(c=> c.Name == className);
          foreach (var item in result)
         {
            Console.WriteLine(item.ID+ " " + item.Name);
         }

}

"=>"左边的就是我们上面匿名方法的参数列表，右边的是方法体，实际上lambda表达式也可以写成如下形式：

Class c => c.Name == className

(Class c) => c.Name == className

(Class c) => {return c.Name == className;}

(x,y)=>x+y;//多参数

等等，函数的返回类型也是由编译器根据"=>"右边的表达式自动推断出来的。

而且需要提到的是由于Filter是ClassCollection的扩展方法的缘故，而且Filter方法返回类型是ClassCollection，所以可以无限扩展下去，例如

var result = classes.Filter( c => c.Name == className).Filter(c=>c.ID>1);

这就是扩展方法的魅力所在！

5）实际上不知不觉，我们已经实现了Linq里面的一个Where功能了

我们现在导入命名空间

using System.Linq;

然后会发现classes这个实例会增加了很多扩展方法例如Where,OrderBy,Union，GroupBy这些方法实际上就是一些给实现了IEnumerable接口的类型的扩展方法，说白了就是针对集合类型的一些相关方法，比如过滤、排序、合并、分组等方法，这些方法的返回类型依然是IEnumerable（大家可以把光标移动到Where方法上，然后调用"转到定义"去看看这些方法的定义就明白了）当然这些方法都离不开我们的Lambda表达式做参数。

private static void LambdaLinq()
       {
           var classes = GetClasses();
           string className = "终极一班";

          //5 C#3.0里面的Where扩展方法（专门给实现了IEnumerable接口的类做扩展）
           var result = classes.Where(c => c.Name == className);
          foreach (var item in result)
         {
            Console.WriteLine(item.ID+ " " + item.Name);
         }

}

我们还可以这样可以无限扩展下去：var result = classes.Where(c => c.Name == className).OrderBy(c=>c.ID);

6）这样写针对IEnumarable类型的查询其实已经不错了，微软觉得还不过瘾，又提供了我们传说中的Linq查询表达式（又是"又"？！）

private static void LambdaLinq()
       {
           var classes = GetClasses();
           string className = "终极一班";

//6 Linq查询表达式

         var result = from c in classes where c.Name==className orderby c.ID select c;
            foreach (var item in result)
            {
                Console.WriteLine(item.ID+" "+item.Name);
            }

}

到这时候你还认识原来的扩展方法吗？所以说语言的抽象确实很好用，和人的思维很接近，但是我们还是要看到它的本质，其实它的本质都是面向对象的一些东西，并没有创造出一些什么新的东西来，这样我们才可以真正理解语言。

7）最后一个稍微复杂一些的Linq查询，就是班级和学生结合的一个连接，连接的条件是班级的id和学生的所属班级id，然后生成一个新的集合，这个集合里面的元素成员包括班级名称和学生名称。涉及到的相关类如下：

class Student
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public int ClassID { get; set; }
    }
    class StudentCollection : List<Student>
    {
    }

获取学生集合的工厂方法：

static StudentCollection GetStudents()
{
    return new StudentCollection()
    {
        new Student { ID=1,Name="大东", ClassID=1},
        new Student{ID=2,Name="亚瑟",ClassID=1},
        new Student { ID=3,Name="小雨", ClassID=1},
        new Student{ID=4,Name="雷克斯",ClassID=1},
        new Student{ID=2,Name="张三",ClassID=2},
        new Student { ID=3,Name="李四", ClassID=2},
        new Student{ID=4,Name="王二麻子",ClassID=2}
    };
}

private static void LambdaLinq()
{
var classes = GetClasses();

var students=GetStudents();

//7 Linq查询表达式 Join

var result = from c in classes
             join s in students on c.ID equals s.ClassID
             select new { ClassName = c.Name, StudentName = s.Name };//匿名类型和初始化器新特性的使用
//var result = classes.Join(students,c=>c.ID,s=>s.ClassID,(c,s)=>new {ClassName=c.Name,StudentName=s.Name}
foreach (var item in result)
{
    Console.WriteLine(item.ClassName + " " + item.StudentName);//注意元素的属性成员已经改变
}

}

.Net Framework 的版本	对应C#的版本
1.1	1.1
2.0,3.0	2.0
3.5	3.0

周克的技术Blog

导航

公告

Linq本质论(1)