.Net 如何实现 LINQ~

2018-06-18 02:55:56来源:未知 阅读 ()

新老客户大回馈,云服务器低至5折

本文内容

  • 引入
  • 实现 LINQ 的两个前提
    • 扩展方法
    • λ 表达式
  • LINQ
  • 参考资料

本文说明 LINQ 是如何实现的,知道这点,才能更好地使用它~

如果你刚接触 LINQ,那么可能不会那么快就理解。因为,LINQ 涉及的技术比较多,可以说它是众多技术的集大成者,因此使用 LINQ 需要你对几个知识点有一定认识,包括泛型委托、扩展方法、匿名函数、λ 表达式(Lambda 表达式),在此基础上,才可能灵活运用 LINQ。这也是为什么 LINQ 在 VS 2008 才出现,而不是之前。

最好是,先学习泛型委托,再通过学习 System.Array 类提高对匿名函数和 λ 表达式的理解。

下载 Demo

引入


如果有一个关于一级方程式赛车冠军 Racer 的集合 ,Racer 包括赛车手的姓名、国家、冠军次数等属性,要想对这个集合操作,比如检索、排序等等,在 C# 3.0 以前,我们要想知道 Brazil 这个国家的冠军都有谁,并且按降序排序,代码如下所示:

IEnumerable<Racer> brazilChampions = champions.Where(
   delegate(Racer r)
   {
       return r.Country == "Brazil";
   }).OrderByDescending(
   delegate(Racer r)
   {
       return r.Wins;
   }).Select(
   delegate(Racer r)
   {
       return r;
   });

其中,champions 是冠军集合。

注意:whereOrderByDescendingSelect 函数都把委托作为函数参数,链式调用最后会返回一个可用 foreach 语句迭代的 IEnumerable 可枚举对象 brazilChampions

虽然上面代码看上去还可以,但是,有 delegate 关键字、有形式参数,还不够简洁。是否可以没有这些啰嗦的东西呢?估计你也想到了——λ 表达式!代码如下所示:

IEnumerable<Racer> brazilChampions = champions.
   Where(r => r.Country == "Brazil").
   OrderByDescending(r => r.Wins).
   Select(r => r);

嗯,简洁多了~可我们又想了,既然是查询,那能不能像数据库查询那样写个 SQL 语句呢?比如:select * from champions t where t.country="Brazil" orderby desc 或类似形式,SQL 中有谓词~

当然有,这就是 LINQ~

但 LINQ 不是一下冒出来的,它有个过程,这也是为什么 LINQ 在 VS 2008 才出现,而不是之前。

了解如何实现 LINQ,才能更好地使用它~

 

实现 LINQ 的两个前提


要想了解 LINQ 是如何实现的,需要知道两个必要的技术点:扩展方法和 λ 表达式。当然,还涉及到泛型委托。

扩展方法

其实,扩展方法并不陌生,我第一次注意这个用法是在 Ext.Net,它的项目里有个工具类程序集。其中的字符串工具类 StringUtils ,如判断字符串是否为“空”,无论是 null,还是长度为 0 都返回 true,从而扩展 .Net 的字符串操作。如下所示 StringUtils 工具类的代码片段:

public static class StringUtils
{
    /// <summary>
    /// Determine is the string is null or empty.
    /// </summary>
    /// <param name="text"></param>
    /// <returns></returns>
    public static bool IsEmpty(this string text)
    {
        return string.IsNullOrEmpty(text);
    }
    
    /// <summary>
    /// Determine is the string is NOT null or empty.
    /// </summary>
    /// <param name="text"></param>
    /// <returns></returns>
    public static bool IsNotEmpty(this string text)
    {
        return !text.IsEmpty();
    } 
 
    ……
 
    /// <summary>
    /// 
    /// </summary>
    /// <param name="text"></param>
    /// <param name="pattern"></param>
    /// <returns></returns>
    public static bool Test(this string text, string pattern)
    {
        return Regex.IsMatch(text, pattern);
    }
    
    /// <summary>
    /// 
    /// </summary>
    /// <param name="text"></param>
    /// <param name="pattern"></param>
    /// <param name="options"></param>
    /// <returns></returns>
    public static bool Test(this string text, string pattern, RegexOptions options)
    {
        return Regex.IsMatch(text, pattern, options);
    }
 
    ……
    
 }

显然,.Net 没有对字符串提供 IsEmpty Test 方法(其实,.Net 提供了 string.IsNullOrEmpty 方法),但如果在你的程序集中定义了这个类,那么就能在你的代码中对字符串用“.”直接调用这些方法,如 "helloworld".IsEmpty()

注意,StringUtils 是静态类。静态类主要是为了共享,静态类的成员也必须是静态的。静态类一般在程序加载的时候被构造。静态类可以有构造函数,但只被调用一次。这样,在你的代码中就不需要实例化这个类,更重要的是,对函数参数 string 类型使用了 this 关键字。

因为,所有的泛型集合都继承了 IEnumerable<T> 接口这样,我们自定义过滤函数 Where,对 IEnumerable<T> 用扩展方法。如下所示,泛型集合根据指定条件返回符合条件的集合:

public static IEnumerable<T> Where(this IEnumerable<T> source, Func<T, bool> predicate)
{
    foreach (T item in source)
    {
        if (predicate(item))
            yield return item;
    }
}

其中,函数 Where 有两个参数:一个是带 thisIEnumerable<T>,另一个是 .net 提供的只有两个输入参数的带返回值的泛型委托 Func<T, TResult>。这样,对任何泛型集合调用 Where 方法都相当于:

champions.Where(Func<T, bool> predicate)

如:

IEnumerable<Racer> brazilChampions = champions.Where(
   delegate(Racer r)
   {
       return r.Country == "Brazil";
   });

既然自定义的泛型集合 Where 方法返回了 IEnumerable<T> 类型,我们当然可以再定义一个对泛型集合的排序函数,比如叫 OrderByDescending(this IEnumerable<T> source, Func<T, int> predicate)

因为自定义函数 Where 的返回类型,也是函数 OrderByDescending 的输入类型,所以它们能形成一个调用链。

λ 表达式

C# 3.0 引入了一个新的语法——λ 表达式(Lambda 表达式)。λ 演算背后是有数学基础的,也就是说,函数声明,包括函数名、形参、返回类型等等都是可以没有的,直接函数体。在对泛型集合调用上面自定义的 Where 函数时,就可以这样写:

IEnumerable<Racer> brazilChampions = champions.Where(r => r.Country == "Brazil");

其中,r 并没有定义。这下代码,简洁多了。

前面说了扩展方法和 λ 表达式,现在离 LINQ 近了。

 

LINQ


我们希望 LINQ 跟 SQL 一样,也有类 select、where、group by、order by 这些关键字,编译器只要把这些关键字映射到相应的扩展方法上就行了。

而 LINQ 的关键字跟 SQL 很像,比如 from、where、orderby、descending 和 select 等。

上面的泛型查询,改成 LINQ 如下所示:

var query = from r in champions
            where r.Country == "Brazil"
            orderby r.Wins descending
            select r;

其中,

  • 1,
where r.Country == "Brazil" 

转换成

Where(r=>r.country=="Brazil");
  • 2,
orderby r.Wins descending

转换成

OrderByDescending(r=>r.Wins)
  • 3,
select r

转换成

Select()

LINQ 查询必须以 from 子句开始,以 selectgroup 子句结束。在这两个子句之间,可以使用 whereorderbyjion 和其他 from 子句。

LINQ 的具体用法你就得自己研究了,不在本文讨论范围内~

 

参考资料


  • .NET C# 声明、实例化和使用委托以及委托在 C# 中的发展
  • 没有 Lambda 演算何来匿名函数——匿名函数(匿名方法和 Lambda)、委托、LINQ
  • wiki λ演算
  • Database SQL Language Reference
  • .NET Framework System.Array.Sort 演示

 

下载 Demo

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:使用.NET 4.0+ 操作64位系统中的注册表

下一篇:.NET Framework System.Array.Sort 数组类,加深对 IComparer、I