C#-ling实战001-linq特性

   linq的执行和数组与列表不同，在运行期间定义表达式时，查询不会立即运行。查询会在迭代数据时运行（foreach），根据执行的顺序可分为立即执行，延迟流式，延迟非流式执行。

 

           

            立即：立即执行意味着在代码中声明查询的位置读取数据源并执行运算。
            返回单个不可枚举的结果的所有标准查询运算符都立即执行。

            延迟
            延迟执行意味着不在代码中声明查询的位置执行运算。
            仅当对查询变量进行枚举操作时才执行运算，
            例如通过使用 foreach（在 Visual Basic 中为 For Each）语句。
            这意味着查询的执行结果取决于执行查询而非定义查询时的数据源内容。
            如果多次枚举查询变量，则每次结果可能都不同。
            几乎所有返回类型为 IEnumerable<T> 或 IOrderedEnumerable< TElement > 的标准查询运算符都以延迟方式执行。
            采用延迟执行方式的查询运算符可以另外分类为流式和非流式。

            流式
            流式运算符不需要在生成元素前读取所有源数据。
            在执行时，流式运算符一边读取每个源元素，一边对该源元素执行运算，并在可行时生成元素。
            流式运算符将持续读取源元素直到可以生成结果元素。这意味着可能要读取多个源元素才能生成一个结果元素。

            非流式
            非流式运算符必须读取所有源数据才能生成结果元素。
            诸如排序和分组等运算属于此类别。
            在执行时，非流式查询运算符读取所有源数据，将其放入数据结构中，执行运算，然后生成结果元素。

1：立即执行

 string[] arraystr = new[] { "Hello", "World" };

2：延迟流式

在foreach时一边计算一边返回结果 

程序在执行enumH时并没有开始枚举

            var arrayenum = (new[] { "Hello", "World" }).AsEnumerable();
            IEnumerable<string> enumH = from strt in arrayenum
                                        where strt.Equals("Hello")
                                        select strt;

 在foreach时才开始枚举计算结果：

            var arrayenum = (new[] { "Hello", "World" }).AsEnumerable();
            IEnumerable<string> enumH = from strt in arrayenum
                                        where strt.Equals("Hello")
                                        select strt;
            foreach (string item in enumH)
            {
                Console.WriteLine("延迟流式："+ item);
            }

 3：延迟非流式：

这种执行方式虽然也是延迟的，但是数据的运算并不是边枚举没运算的，而是直接计算所有数据，然后延迟输出。所以在监视器中无法看到current元素

            int[] vals = { 10,545,659,1,56,125,394,1,12,65,45,36,25};

            IEnumerable<int> ordval = from iv in vals
                                      orderby iv descending
                                      select iv;
            foreach (int item in ordval)
            {
                Console.WriteLine("延迟非流式：" + item);
            }

 

最后附上所有linq方法的执行方式：

标准查询运算符	返回类型	立即执行	延迟流式执行	延迟非流式执行
Aggregate	TSource	X
All<TSource>	Boolean	X
Any	Boolean	X
AsEnumerable<TSource>	IEnumerable<T>		X
Average	单个数值	X
Cast<TResult>	IEnumerable<T>		X
Concat<TSource>	IEnumerable<T>		X
Contains	Boolean	X
Count	Int32	X
DefaultIfEmpty	IEnumerable<T>		X
Distinct	IEnumerable<T>		X
ElementAt<TSource>	TSource	X
ElementAtOrDefault<TSource>	TSource	X
Empty<TResult>	IEnumerable<T>	X
Except	IEnumerable<T>		X	X
First	TSource	X
FirstOrDefault	TSource	X
GroupBy	IEnumerable<T>			X
GroupJoin	IEnumerable<T>		X	X
Intersect	IEnumerable<T>		X	X
Join	IEnumerable<T>		X	X
Last	TSource	X
LastOrDefault	TSource	X
LongCount	Int64	X
Max	单个数值、TSource 或 TResult	X
Min	单个数值、TSource 或 TResult	X
OfType<TResult>	IEnumerable<T>		X
OrderBy	IOrderedEnumerable<TElement>			X
OrderByDescending	IOrderedEnumerable<TElement>			X
Range	IEnumerable<T>		X
Repeat<TResult>	IEnumerable<T>		X
Reverse<TSource>	IEnumerable<T>			X
Select	IEnumerable<T>		X
SelectMany	IEnumerable<T>		X
SequenceEqual	Boolean	X
Single	TSource	X
SingleOrDefault	TSource	X
Skip<TSource>	IEnumerable<T>		X
SkipWhile	IEnumerable<T>		X
Sum	单个数值	X
Take<TSource>	IEnumerable<T>		X
TakeWhile	IEnumerable<T>		X
ThenBy	IOrderedEnumerable<TElement>			X
ThenByDescending	IOrderedEnumerable<TElement>			X
ToArray<TSource>	TSource 数组	X
ToDictionary	Dictionary<TKey, TValue>	X
ToList<TSource>	IList<T>	X
ToLookup	ILookup<TKey, TElement>	X
Union	IEnumerable<T>		X
Where	IEnumerable<T>		X