Enumerable Where Select

Linq 读作 link 语言集成查询（Language Integrated Query），让我们可以像操作数据库那样操作内存数据。它有个特点，在使用时执行。
如何在使用时获取数据，就要用到一个关键字yield,使用时和return一起出现。

先看个例子

        static void Main(string[] args)
        {
            foreach (var item in GenerateStrings())
            {
                Console.WriteLine(item.ToString());
            }
        }
        static IEnumerable<string> GenerateStrings()
        {
            for (int i = 0; i < 10; i++)
            {
                yield return i.ToString();
            }
        }

在foreach的数据源中，调用这个方法。在输出那设一个断点，单步执行，可以看到，数据源并不是在方法执行完成后再返回到foreach中，而是每调用到下一个数据时，在方法中获得下一个数据。这就是yield return.
这种做法有什么好处？在需要的时候调用，数据只在需要用到的时候调入内存，而不是把整个集合都调入内存，节省存储空间，在这个例子里其实并不能很好的体现好嘛。

        static void Main(string[] args)
        {
            var sequence = GenerateStrings();//==①
            sequence = sequence.Where(x => x.Length < 2);//==②    x => x.Length < 2//==⑤
            foreach (var item in sequence)//==③
            {
                Console.WriteLine(item.ToString());//==⑥
            }
        }
        static IEnumerable<string> GenerateStrings()//==④
        {
            for (int i = 8; i < 100; i++)
            {
                yield return i.ToString();
            }
        }

在遇到第①，②句时，并没有进到 GenerateStrings其中，而是遇到foreach时，依次进到GenerateStrings中，取到返回值后，再判断⑤子句，成立后才会输出。
但我在调试的时候明明没有进到GenerateStrings，他就已经有结果了，不懂。

再看一个，我们自己写一个扩展方法，功能同上一个的where子句

    public static class MyLinq
    {
        //一个扩展方法
        public static IEnumerable<string> MyWhere(this IEnumerable<string> source)
        {
            foreach (string item in source)
            {
                if (item.Length < 2)
                    yield return item;
            }
        }
    }
    class Program
    {

        static void Main(string[] args)
        {
            var sequence = GenerateStrings();
            sequence = sequence.Where(x => x.Length < 2);
            var sequence2 = GenerateStrings();
            sequence2 = sequence2.MyWhere();
            foreach (var item in sequence)
            {
                Console.WriteLine(item.ToString());
            }
            foreach (var item in sequence2)
            {
                Console.WriteLine(item.ToString());
            }
            Console.ReadKey();
        }
        static IEnumerable<string> GenerateStrings()
        {
            for (int i = 8; i < 100; i++)
            {
                yield return i.ToString();
            }
        }

    }

输出都是一样的
8
9
8
9

介绍一下第二个foreach的执行过程
遇到sequence2 = sequence2.MyWhere();时是先不执行的
在foreach到的时候才会执行MyWhere
到MyWhere中的foreach后，需要一个数据源
那么就去执行var sequence2 = GenerateStrings()
依次的获取数据，拿到一个8后，判断长度是否小于2，满足，返回8，输出。
9也是一样
到10的时候，判断不小于2
重复获取数据，判断，直到99，没有了，退出。

下面改一下那个扩展方法

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

还有这里
sequence2 = sequence2.MyWhere(x=>x.Length<2);

这样以后，我们的扩展方法就更加灵活，功能上和C#提供的Where就一样了。后面是一个委托，用来判断条件，返回一个bool值，在if里判断。
再牛逼一点，把我们的MyWhere变成一个泛型方法

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

改完这个，主函数里是不用动的，泛型大法好。会玩的你知道下一步怎么玩了么？

        static IEnumerable<int> GenerateIntegers()
        {
            for (int i = 8; i < 100; i++)
            {
                yield return i;
            }
        }

写个返回整数的方法咯。
var sequence3 = GenerateIntegers().MyWhere(x => x % 7 == 0);
这个就可以拿到所有7的倍数啦。
但是要注意到，我们刚才那个泛型方法没有任何错误检查机制，所以…

下面是select

select就比较简单了
var sequence4 = GenerateIntegers().Select(x => x.ToString());
var sequence5 = GenerateIntegers().Select(x =>true);
自己感受一下select后面的lambda表达式

如果，我们来重写一下这个select

        public static IEnumerable<string> MySelect(this IEnumerable<int> source,Func<int,string> selector)
        {
            foreach (int item in source)
            {
                yield return selector(item);
            }
        }

像这样
var sequence4 = GenerateIntegers().MySelect(x => x.ToString());
感受一下，结果是一样的。
那么我们又可以写个泛型扩展方法了

        public static IEnumerable<TResult> MySelect<TSource,TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
        {
            foreach (TSource item in source)
            {
                yield return selector(item);
            }
        }

其实select 有一个重载的版本是可以获取索引的

            var sequence6 = GenerateIntegers().Select((x,index)=>new { index, str=x.ToString()+"str" });
            foreach (var s in sequence6)
            {
                Console.WriteLine("{0}=={1}", s.index, s.str);
            }

借助一个匿名类型，我们可以同时得到索引和内容。