哼哼, LINQ!

    习惯了用LINQ的人一定用的很爽, 整天LINQ来LINQ去的, LINQ确实是很好的东西, 简洁, 方便, 最重要的是统一了数据的查询方式, 使得程序员不必关心数据的出处(绝对不关心数据的出处是不可能的, 但至少统一了查询方式, 统一了"项目接口"), 这一点对软件工程很有意义.

    不过...........它是如何实现的呢?...................

    恩, 又是语法糖, 不这回是个超级大语法糖, 外带一些类库糖.

    如果把整个LINQ比作一个人，那我们先来写一个麻雀：

    //定义委托类型。
    public delegate T TheFun<T>();

    //定义一个接口。
    public interface IHaveCount
    {
        int MyCount1 { get; set; }
        int MyCount2 { get; set; }
    }

    //这是类库糖
    public static class HaveCountOperations
    {
        //使用扩展方法这个语法糖。
        public static IHaveCount AddCount2ToCount1(this IHaveCount haveCount, TheFun<bool> ifDoOrNot)
        {
            //执行委托，用来判断是否执行。
            if (ifDoOrNot.Invoke())
            {
                haveCount.MyCount1 += haveCount.MyCount2;
            }
            return haveCount;
        }
    }

    //定义一个类
    public class A : IHaveCount
    {
        public string Name;

        #region IHaveCount Members
        public int MyCount1 { get; set; }
        public int MyCount2 { get; set; }
        #endregion
    }

    然后调用它：

            A a = new A { MyCount1 = 100, MyCount2 = 2 };
            a.AddCount2ToCount1(() => true).AddCount2ToCount1(() => true).AddCount2ToCount1(() => false);

            Console.WriteLine(a.MyCount1.ToString());

    结果为104。

    
    我们回过头来看一下，不难发现在这个麻雀结构中最关键的就是类库糖中针对接口IHaveCount的扩展方法，麻雀虽小，但很能反映问题。LINQ中，最本质的也是这样一种设计思路。伟大的LINQ设计师当初就要面对这样一种场景：如何针对不同的载体类型，统一数据集的查询方式？

    绝不可能去重写所有的载体类型比如List、Array，但这些集合类型都实现了同样的一个接口：IEnumerable<T>，也就是说都是可以使用迭代器查看数据集中的每一个数据的，只要能把查询条件以某种方式传到foreach结构中，然后再返回符合条件的同样继承IEnumerable<T>的集合不就可以设计出类似sql的查询语言？查询条件可以使用委托，下一个问题是如何返回集合，当然可以新new一个，不过聪明的LINQ设计师却使用了yield return，呵，这样一来，不仅减少了代码量，还顺便实现了延迟加载的特性。这样一来，核心设计便没有问题了，可是使用起来却比较难看，于是有了扩展方法，让类库糖调用起来像实例方法一样方便，于是又产生了匿名委托，匿名方法等等等等，可以说C# 3.0绝大部分新特性都被用在了LINQ上。再结合泛型方法，泛型委托，LINQ看起来竟显得如此漂亮。

     如果把整个LINQ比作一个人，那我们最后再来写一条狗：(编译完了强烈建议大家用Reflector反编译仔细研究研究)

    public static class LINQDogOperations
    {
        public static IEnumerable<TResult> LittleDogSelect<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
        {
            foreach (TSource ts in source)
            {
                yield return selector(ts);
            }
        }

        public static IEnumerable<TSource> LittleDogWhere<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            foreach (TSource ts in source)
            {
                if (predicate(ts))
                {
                    yield return ts;
                }
            }
        }

随便调用试试：

    class Program
    {
        static void Main(string[] args)
        {
            List<TestClass> test = new List<TestClass>();

            for (int i = 0; i < 1000; i++)
            {
                test.Add(new TestClass { ID = i, Password = i.ToString() });
            }

            var v1 = test.LittleDogSelect((i) => new { i.ID, i.Password }).LittleDogWhere((c) => c.ID > 500);

            Console.WriteLine(v1.Count().ToString());
        }
    }


    public class TestClass
    {
        public int ID;
        public string Password;
        public int State;
    }

    呵呵，当一切语法糖条件具备，看吧，就那几行代码，感谢万能的编译器。感谢聪明的设计师。