linq入门学习 linq to object

遍历列举的时候，序列中的元素才会被yield返回。

现在我们来讨论下延迟查询的作用。延迟查询有什么有点和什么缺点呢？

优点：1. 执行过程中减少资源的占用，提高性能。数据只在使用的时候才读取出来，而不用每次查询都要读取出来。

??????? 2. 实际保存的是查询条件和约束，源数据发生变化不会影响查询结果的准确性。

int [] list = { 1 ,128)">2 ,128)">3 ,128)">4 ,128)">5 ,128)">6 ,128)">7 }; 4 var result = list.Where(n => n > 5 result.Dump("结果是：5,6,7"); 6 list[ 6 ] = 0 ; 7 result.Dump("结果是：5,6"); ?????? 在例子中，我们查询条件是大于4的所有数字，但是中途数组中的数据发生变化，原来的数字 7 修改为了 0，因此实际我们的查询结果应该也会变化。

因此延迟查询可以保证我们一直能够得到想要的数据集合。

?

缺点：数据可能不一致造成异常。由于我们的查询结果是在实际遍历的时候才会读取出来，因此查询条件的异常错误也就只会在实际遍历时候才会产生，前

??????? 面我们总结的延时查询的优点2，在某些时候也会成为我们的错误。因此在使用的时候要很仔细。

??????? 下面我们还是用代码示例来说明这个问题。

  
  

   
   4 
   
    var result
   
   =
   
   list.Select(n
   
   =>
   
   100
   
   /
   
   n).ToList(); 
   
   5 
   
    result.Dump();
   
   result保存查询结果
   
   ?
   
   }
  
  

在查询操作符之中，有部分操作符并不是延迟的，下面列举出非延迟和延迟的操作符.

（图片来源：《Pro?LINQ: Language Integrated Query in C# 2008》）：

3.扩展函数

前面我们说到过，IEnumerable<T>和IEnumerable是通过扩展函数提供查询操作功能，这里我们对扩展函数做个简单说明,如果你已经了解了扩展函数,

可以直接跳过.扩展函数允许你直接在已经存在的类型上添加函数,而不用修改原有类型,或者通过继承的方式.扩展函数是一种特殊的静态函数,但是是需要通过类

型的实例来调用,下面是扩展函数的格式:

public static IEnumerable < T > Where < T > ( 2 this IEnumerable < T > source, 3 Func < T,255)">int ,255)">bool > predicate);

作用：从原序列中获取指定数量的元素集合，返回新的序列。

参数：int count

  
  

   
   var result
   
   =
   
   items.Take(1
   
   ); //描述： 返回序列的第一个元素 结果为"Csharp"
  
  

作用：从原序列中跳过指定数量的元素，返回剩余元素组成的序列。

  
  

   
   var result= items.Skip(2);
  
  
  
  

   
   ?//描述： 跳过两个元素返回剩余的元素组成的序列
  
  
  
  

   
   //结果: {
   
    7.?SkipWhile
 
 作用：从原序列中跳过满足条件的元素，返回剩余元素组成的序列。
 
 参数：Func<T,204); padding-top:5px; padding-right:5px; padding-bottom:5px; padding-left:5px; overflow-x:auto; overflow-y:auto; margin-top:5px; margin-right:0px; margin-bottom:5px; margin-left:0px"> 
 
  
  

   
   var result= items.SkipWhile(p=>p.Contains(‘h’));
  
  
  
  

   
   ?//描述： 跳过元素中有包含字符h的元素，返回其他元素
  
  
  
  

   
   //结果: {
   
   "cpp
   
   ,192)">OrderBy 和 OrderByDescending
 
 　　8.ThenBy和?ThenByDescending
 
 　　作用：在已排序后的序列进行第二种方式排序。
 
 重载参数1：Func<T,K> Selector
 
 重载参数2：Func<T,K> Selector,IComparer<K> comp
 
1 
   
   var result
   
   =
   
   items.OrderBy(s
   
   =>
   
   s.Length).ThenBy(s
   
   =>
   
   s[
   
   0
   
   ]); 
   
   ?
   
   描述：先按照长度排序，然后按照字符串首字母排序
  
  
 
 
 9.Join
 
 作用：通过指定的键连接多个序列组合成新序列，和SQL的内连接相似。
 
 参数：IEnumerable<U> inner,Func<T,K> outerKey,Func<U,K> innerKey,U,V> result
 
string
   
   [] items1
   
   =
   
   {
   
   aa
   
   bbb
   
   ccc
   
   dddd
   
   4 
   
    
   
   string
   
   [] items2
   
   =
   
   {
   
   eee
   
   ff
   
   gggg
   
   h
   
   iii
   
   5 
   
    var r
   
   =
   
   items1.Join(items2,i
   
   =>
   
   i.Length,j
   
   =>
   
   j.Length,(i,j)
   
   =>
   
   new
   
    {result
   
   =
   
   string
   
   .Format(
   
   {0}:{1}
   
   6 
   
    r.Dump(); 
   
   7 
   
   } 
   
   8 
   
   ?
   
   将两个序列按照长度连接组成新序列
   
    结果： result aa：ff bbb：eee bbb：iii ccc：eee ccc：iii dddd：gggg 
   
   ?
  
  

1.返回的序列是匿名类型，可以自定义结果序列的列，但是同时需要指定名称（result就是名称）。

2.由于是匿名类型，因此只能使用var关键字

10.GroupBy

作用：对序列按照指定方式进行分组，生产新的分组序列

返回值：IEnumerable<IGrouping<K,T>>

1 22 33 444 555 6666 4 var r1 = from item in items 5 group item by item.Length into g 6 select new {g.Key}; 7 r1.Dump(); 等同于下面 ? var r2 = items.GroupBy(item => item.Length).Select(g => g.Key); 11 r2.Dump(); 12 } 结果： 1 2 3 4

作用：组合两个序列为一个序列，去除重复的元素

参数：IEnumerable<T> second

777 5 items.Union(items2).Dump(); 6 } 结果： 1 22 33 6666 777 ?

作用：将序列转换为数组 或 列表

是否延迟：No

参数：none

4 var r = items.Where(n => n.Length > 2 ).ToArray(); 5 var r2 = items.Where(n => n.Length > 2 ).ToList(); 6 } 7 ? r和r2保存的是实际的数组和列表，而不是查询条件对象

作用：转换序列为泛型字典Dictionary of type <K,T>

4 items.ToDictionary(k => k.Length).Dump(); 错误：重复键 ? items.ToDictionary(k => k,k => k.Length).Dump(); 6 } 结果： key value ? 1 1 ? ? 22 2 ? ? 33 2 ? ? ? 444 3 ? ? ? 555 3 ? ? 6666 4 5.后记

在上面的例子中只列出了几个常见，某些比较简单的操作符比如：Min，Max，Count，ElementAt等从字面意思都可以看出来就没有做描述。

由于理解不够深入，存在的问题请指正。