走进Linq--Linq横空出世篇

本系列文章
走进Linq-Linq横空出世篇
走进Linq-辉煌的背后
走进Linq-Linq大观园

走进Linq-Linq to Objects(上)基础篇

某日编程大师云游到某处，见一刚毕业不久学过两天C# 和两天SQL 的coder 在那里发牢骚，为啥我要写这么多for ，这么多if 才能查询出我需要的数据，为啥我不能像SQL 那样，发送一条命令告诉数据库我需要啥样的数据，它就给我返回来。

编程大师如是说：傻小子，像SQL那叫第四代编程语言，常存在于象牙塔和研究所里面的学究语言，还有个高雅的名字：函数编程。它只需要你告诉它要什么，而不需要告诉它怎么做。而你使用的C#语言属于命令式编程，你必须像发送命令一样一步步的告诉你的机器怎么做。
发牢骚的coder回了一句：不懂，我只是想不通，数据库能做这样的处理，为啥C#这么牛的语言不能呢。
编程大师心里想着：这是不可能的事情，因为C#它是强类型语言，)*&)(&)*)()*&%&%&^（后面省去200字）。
天色还未晚，编程大师就急匆匆的回家了，他心里一直记着那位发牢骚的coder的话：为什么不能，为什么不能。
晚上，编程大师做了一个梦，一个奇怪的梦，他的师傅“白眉”只说了三个字母：DSL。
编程大师想着，DSL，领域专用语言，师傅要对我说什么呢，难道和今天我遇见的事有关？
上面这段文字是一段调侃，调节一下气氛，呵呵。
我觉得Linq就是一种DSL，在C#等常规语言上抽象起来的，面向数据处理领域的特定“语言”，当然，它的根基还是这些常规语言。
select,from,where,group等关键字本来只是在SQL里出现，现在把它们引入到C#这些常规编程语言中。
那C#等是如何做到的呢？是在CLR底层支持的么？不是。既然“编译器”可以将C#编译成MSIL，那为什么编译不能干更多一点事情？将这些为了领域编程而出现关键字编译成原始语法。

 

下面还是从实例来说明吧：
我们有一个图书类Book，先已经有一个填充有数据的Book集合，我们需要从这个集合里查找出单价小于50的书籍：

using  System;
/**/ /// <summary>
/// 图书类
/// </summary>
public   class  Book
{
    /**//// <summary>
    /// 图书名称
    /// </summary>
    public string Title { get; set; }
    /**//// <summary>
    /// 单价
    /// </summary>
    public float Price { get; set; }
    /**//// <summary>
    /// 作者
    /// </summary>
    public string Author { get; set; }
    /**//// <summary>
    /// ISBN号
    /// </summary>
    public string ISBN { get; set; }
}

如是我可以写这样的代码：

public   static   class  Helper
{
     public   static  IList < Book >  SearchBookByPrice()
    {
         IList < Book >  books  =   // .. // 初始化一个Book集合
         IList < Book >  results  =   new  List < Book > ();
         foreach (Book book  in  books)
        {
             if (book.Price  <   50 )
            {
                   results.Add(book);
            }
        }
         return  results;
    }
}  

现在是根据单价查找，那如果我要按照书籍名称查找或者按照作者查找怎么办？那只有重写这个方法了。但是你想想，我们的查找条件到最后只不过是一个true 或者false ，只要if() 里面的表达式为true 我们就将其添加到返回结果的集合中，我才不管里面的表达式详细的是什么呢，ok ，那这样我们就可以进一步改进这个方法了：

public   static   class  Helper
{
     public   delegate   bool  Condtion(Book book);

     public   static  IList < Book >  SearchBook(Condtion condition)
    {
        IList < Book >  books  =   // .. // 初始化一个Book集合
        IList  <  Book  >  results  =   new  List < Book > ();
         foreach  (Book book  in  books)
        {
             if  (condition(book))
            {
                results.Add(book);
            }
        }
         return  results;
    }
}

看看我们如何调用改进后的方法：

public   bool  ConditionTitle(Book book)
{
    return  book.Title  ==   " yuyi " ;
}
IList < Book >  results  =  Helper.SearchBook( new  Condition(ConditionTitle));

我们将查询条件使用委托解决了，只要传递一个接收Book 作为参数，返回bool 值的方法进去就可以查询满足条件的书籍了，但是，为了这个委托，我们还得先定义一个新方法，然后。。。。太麻烦了，为此C# 2.0 为我们提供了匿名方法，专门针对这些只有“一句话方法”：

IList < Book >  results  =  Helper.SearchBook( delegate (Book book) {  return  book.Title  ==   " yuyi " ; });

代码是减少不少，可这种写法还是不“人性化”，这还是一种人向计算机妥协的结果，才产生了这种怪异的写法，如是 C# 3.0 给我们提供了 Lambda 表达式 :

IList < Book >  results  =  Helper.SearchBook(book  =>  book.Title  ==   " yuyi " );

代码更短了，写法也越来越向人类语言靠近了( 这也许就是计算机语言的发展历史，随着计算机越来越智能，总有一天必会是计算机向人类妥协) 。
不过这里还有一点不爽，每一次调用这个查找方法都要带Helper ，要是IList<Book> 自己就这个方法该多好。这个想法很好，C# 3.0 里还为我们提供了扩展方法：

public   static   class  Helper
{
    public delegate bool Condtion(Book book);

    public static IList<Book> Where(this IList<Book> books,Condtion condition)
    {
        IList < Book > results = new List<Book>();
        foreach (Book book in books)
        {
            if (condition(book))
            {
                results.Add(book);
            }
        }
        return results;
    }
}

仔细比较一下这个实现与刚才的实现有何不同 ( 我们还给它起了一个更好听的名字 Where ，是不是和 SQL 更像了 ) ，现在我们可以这样调用了：

IList < Book >  results  =  books.Where(book  =>  book.Title  ==   " yuyi " );

Books 是一个IList<Book> ，这行代码是多么的自然而优雅。依葫芦画瓢，我们可以到处这样书写代码了，不仅仅可以查找书籍，还可以查找帐户，一切处理集合查找的方法我都希望这样做，终于有一天你厌烦了，查找书，查找帐户，等等，他们之间没有什么差异，为什么我们要做这么多重复的工作呢，所有的IList<T> 都继承自IEnumerable<T> ，我们为啥不给IEnumerable<T> 添加一个Where 方法，这样我们不就一劳永逸了么，现在该是泛型施展才华的地方了：

public   static   class  Helper
{
     public   delegate   bool  Condtion < T > (T t);
     public   static  IEnumerable < T >  FindBy < T > ( this   IEnumerable < T >  items, Condtion < T >  condition)
    {
         foreach  (T t  in  items)
        {
             if  (condition(t))
            {
                 // C# 2.0里出现的一个关键字，返回一个迭代器
                 yield   return  t;
            }
        }
    }
}

现在，不管是IList<Book> 还是IList<Account> 都可以使用这个Where 方法了
但是做集合操作的时候我们不仅仅需要Where ，还需要OrderBy ，Group 等等，我想把所有的SQL 能干的都移植过来。当然微软也意识到了这点，如是在.net 3.5 里，微软发布了我们梦寐以求的Linq ，将查询集成到语言里面来。它给IEnumerable<T> 添加了很多扩展方法，这样你可以很自然的去调用。你可以使用Reflector 打开System.Core.dll ，打开System.Linq 命名空间，在这个命名空间里有一个Enumerable 类，这里面就是微软为我们添加的扩展方法，看看，是不是SQL 里所有的东西都可以在这里找到了。

好了，就此搁笔吧，这一篇作为我的走进Linq系列的开篇，在接下来我会为你把Linq大卸八块。

转载于:https://www.cnblogs.com/yuyijq/archive/2008/07/15/1243714.html