LinQ体验

[size=large]前面两章写了扩展方法和Lambda表达式，其实真正的主角现在出场了,那就是曾经有人问我，你会LinQ吗？
LinQ(Language Integrated Query)语句集成查询。.NET Framework3.5中的最亮点。
不说了，直接上例子。相信大家都能看明白[/size]

      private void button1_Click(object sender, EventArgs e)
        {
            //定义一个整形数组
            int [] arr =  { 123, 1223, 45, 67, 1, 23, 23, 45, 67, 78 };
            //找出数组中小于100的数
            #region  没有Linq之前我们这样做
            //ArrayList arrList = new ArrayList();
            //for (int i = 0; i < arr.Length; i++)
            //{
            //    if (arr[i] < 100)
            //    {
            //        arrList.Add(arr[i]);
            //    }
            //}
            //  //输了arrList元素
            //foreach (int i in arrList)
            //{
            //    Console.WriteLine(i);
            //}
            #endregion

            #region 有了Linq可以这样做
              var Result = arr.Select(p => p).Where(p => p < 100);
             IEnumerator<int> IResult = Result.GetEnumerator();
               while (IResult.MoveNext())
               {
                   Console.WriteLine(IResult.Current);
               }
               #endregion
        }

 private void button2_Click(object sender, EventArgs e)
        {
            List<string> list = new List<string>();
            list.Add("zhang san");
            list.Add("zhang san feng");
            list.Add("li xiao xiao");
            list.Add("wang  wu");
            list.Add("song  guo jun");
            list.Add("song jun jun");
            //Linq to object，lambda表达式
           // var Result = list.Select(p => p);
              //Linq排序
            //var Result = list.OrderBy(p => p);
            //按条件输入
            var Result = list.Where(p => p.StartsWith("song")).Select(p => p);
            //使用拓展方法，输入泛型集合中的元素
            Result.Print();

            //普通的访问
            //foreach (string s in list)
            //{
            //    Console.WriteLine(s);
            //}
        }

   //静态类
    public static class ExpandClss
    {
        //静态类中的拓展方法
        //为IEnumerable<string>接口类型对象定义方法，实现元素的输出
        public static void Print(this IEnumerable<string> a)
        {
            IEnumerator<string> result = a.GetEnumerator();
            while (result.MoveNext())
            {
                Console.WriteLine(result.Current);
            }
        }

       //为IEnumerable<int>接口类型对象定义方法，实现元素的输出    
        public static void Print(this IEnumerable<int> a)
        {
            IEnumerator<int> result = a.GetEnumerator();
            while (result.MoveNext())
            {
                Console.WriteLine(result.Current);
            }
        }
    }

   private void button3_Click_1(object sender, EventArgs e)
        {
            int[] arr = {80, 12, 13, 24, 345, 546, 77, 89, 100, 23,9 };
            //求数组中的最大数
            Console.WriteLine(arr.Max());
            //求数组中的最小数
            Console.WriteLine(arr.Min());
            //求数组中的平均数
            Console.WriteLine(arr.Average());
            //求数组中元素的个数
            Console.WriteLine(arr.Count());
            Console.WriteLine(arr.Length);
            Console.WriteLine("--------------------------------");
            //排序类

            //将第一个数字转换成字母，然后按照字母排序
           // var Result = arr.OrderBy(p => p.ToString().Substring(0, 1));
            //二次排序
            //var Result = arr.OrderBy(p => p.ToString().Substring(0, 1)).ThenBy(p => p);//2次

            //分区类
            //var Result = arr.Skip(3).Take(4);
            //var Result = arr.SkipWhile(p => p > 11);//跳过满足条件的元素，然后返回剩余元素。
            //var Result = arr.TakeWhile(p => p > 12);


            //生成类--类中的静态方法
           //var Result =  System.Linq.Enumerable.Range(10, 10);
             var Result = System.Linq.Enumerable.Repeat("abc", 10);
           Result.Print();
        }
    }

[size=large]以上例子都是LinQ的查询方法。这些方法都可以为实现了Ienumerable<Tsource>泛型接口类型的对象所调用。[/size]
[size=large]下面是LinQ的查询语法(query syntax)
LinQ的查询语句主要由三部分组成
*定义数据源
*创建查询
*执行查询[/size]

 private void btnLanguage_Click(object sender, EventArgs e)
        {
            //Linq查询语句,LinQ TO Object
             //1.这里定义查询数据源
            List<string> list = new List<string>();
            list.Add("zhang san");
            list.Add("song jun jun");
            list.Add("zhang san feng");
            list.Add("li xiao xiao");
            list.Add("wang  wu");
            list.Add("song  guo jun");
            //输出list中的所有元素
             //var Result = from p in list select p;
           //输出姓song的元素， 语句和方法的混编模式
            // var Result = (from p in list select p).Where(p => p.StartsWith("song"));
           //2.这里创建查询
            //排序
          var Result = from p in list orderby p select p;
          //3.执行查询,此处是调用了一个扩展方法，也可以使用foreach来遍历
          Result.Print();
        }

   public static class ExpandClss
    {
        //静态类中的拓展方法
        public static void Print(this IEnumerable<string> a)
        {
            IEnumerator<string> result = a.GetEnumerator();
            while (result.MoveNext())
            {
                Console.WriteLine(result.Current);
            }
        }

        public static void Print(this IEnumerable<int> a)
        {
            IEnumerator<int> result = a.GetEnumerator();
            while (result.MoveNext())
            {
                Console.WriteLine(result.Current);
            }
        }
    }

下图显示了完整的查询操作。 在 LINQ 中，查询的执行与查询本身截然不同；换句话说，如果只是创建查询变量，则不会检索任何数据。
[img]http://i.msdn.microsoft.com/dynimg/IC107892.png[/img]
[size=large]该查询表达式包含三个子句：from、where 和 select。 （如果您熟悉 SQL，您会注意到这些子句的顺序与 SQL 中的顺序相反。）from 子句指定数据源，where 子句应用筛选器，select 子句指定返回的元素的类型。目前需要注意的是，在 LINQ 中，查询变量本身不执行任何操作并且不返回任何数据。 它只是存储在以后某个时刻执行查询时为生成结果而必需的信息。延迟执行
如前所述，查询变量本身只是存储查询命令。 实际的查询执行会延迟到在 foreach 语句中循环访问查询变量时发生。 此概念称为“延迟执行”，有“延迟执行”也就有“强制执行”

强制立即执行
对一系列源元素执行聚合函数的查询必须首先循环访问这些元素。 Count、Max、Average 和 First 就属于此类查询。 由于查询本身必须使用 foreach 以便返回结果，因此这些查询在执行时不使用显式 foreach 语句。 另外还要注意，这些类型的查询返回单个值，而不是 IEnumerable 集合。 下面的查询返回源数组中偶数的计数：
[/size]

private int OutputSum()
{
  int[] numbers=new int[]{1,2,3,4,5,6,7,8,9,10}

  var evenNumQuery = 
      from num in numbers
      where (num % 2) == 0
      select num;

  int evenNumCount = evenNumQuery.Count();
}

[size=large]若要强制立即执行任意查询并缓存其结果，可以调用 ToList<TSource> 或 ToArray<TSource> 方法。[/size]

private IList<T> Test()
{

  List<int> numQuery2 =
       (from num in numbers
        where (num % 2) == 0
        select num).ToList();

      // or like this:
      // numQuery3 is still an int[]

 }

private Array Test1()
{
    var numQuery3 =
        (from num in numbers
         where (num % 2) == 0
         select num).ToArray()
 }

[size=large]此外，还可以通过在紧跟查询表达式之后的位置放置一个 foreach 循环来强制执行查询。 但是，通过调用 ToList 或 ToArray，也可以将所有数据缓存在单个集合对象中。 [/size]

[size=large]总结:LinQ的方法语法和查询语法之间并无语义上的区别。CLR本身并不理解查询语句，它只理解查询方法，编辑器负责在编译时将查询语句翻译为查询方法.大部分查询方法都有对应的查询语句，如select()对应select,where()对应where,order()对应order。部分查询方法目前c#中还没有查询语句，如count()和max()这时只能采用
查询方法
查询语句+查询方法混合的模式
一般情况下，见议使用可读性更高的查询语句。而且这里只是一些简单的使用说明，更多的内容还需要以后慢慢的研究积累。[/size]