LinQ快速入门

（一）LINQ定义：

•LINQ（Language Integrated Query）即语句查询。LINQ主要包含三部分：LINQ to Object、LINQ TOXML和LINQ t to ADO.NET.

（二）LINQ初体验：

•拓展方法：目的对现有的类提供额外的方法增强该类的功能。

                   该类型的所有方法都可以使用这种方法。

我们都知道string类中有方法将字符串手写字母转化为大写字母（小写字母），我们用拓展方法-将字符串的首字母转化为大写字母的方法。

        private void btnExtramethod_Click(object sender, EventArgs e)
        {
            //拓展方法-----
            string s = "asdhasdh";
            Console.WriteLine(s.ToUpper());
            Console.WriteLine(s.ToLower());
            Console.WriteLine(s.ToPascal());
            Console.WriteLine(s.ToPascal(2)); 

        }

方法一：

         方法一：
        //将字符串的手写字母转化为大写字母的方法
        public string ToPascal( string s) //this后带类型，表明该类型添加拓展方法
        {
            return s.Substring(0, 1).ToUpper() + s.Substring(1).ToLower();
        }

方法二：定义一个静态类，在静态类中写：

   方法二：定义一个静态类，在静态类中写
    public static class ExtraClass
    { 
        //拓展方法--特殊的静态方法--为string类型添加特殊的方法ToPascal
        public static string ToPascal(this string s) //this后带类型，表明该类型添加拓展方法
        {
            return s.Substring(0, 1).ToUpper() + s.Substring(1).ToLower();
        }
        public static string ToPascal(this string s,int len) //this后带类型，表明该类型添加拓展方法
        {
            return s.Substring(0, 1).ToUpper() + s.Substring(1,len).ToLower() + s.Substring(len + 1);
        }
}

•拓展方法的缺点是：

1、拓展方法特定的命名空间内有效。

2、拓展方法的优先级低于同名的类方法。

•用LINQ的一个小Dome

我们写一段获取大于50的数，我们通常这样写：

int[] arr = { 123, 12, 3, 12, 15, 4, 5, 46, 47, 56, 176 };
            //获取大于50的数
            ArrayList result = new ArrayList();
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i] > 50)
                {
                    result.Add(arr[i]);
                }
            }
            //打印reult就OK了
            for (int i = 0; i < result.Count; i++) {
                Console.WriteLine(result);
            }

有了linq我们这样写：

            //获取到大于50的数
            IEnumerable ie = arr.Select(p => p).Where(p => p > 50);
            //输出---改代码可以复用
            IEnumerator result = ie.GetEnumerator();
            while (result.MoveNext())
            {
                Console.WriteLine(result.Current);
            }

（三）Lambda表达式：

•Lambda表达式是LINQ的基本语法。

•Lambda最基本的表达式如下：

             （参数列表）=>{方法体}

说明：参数类表中的参数类型可以是明确类型或者是推断类型。

              如果是推断类型，则参数的数据类型将由编译器根据上下文自动推断出来。

•Lambda表达式的由来：

              Lambda表达式是有.net FrameWork1.0中委托的概念到2.0中的匿名方法过渡来的。

用.net FrameWork1.0中委托的概念：

定义一个委托：

public delegate string deleTransfer(string s);//注意方法签名

调用委托：

           //Linbda 来源
            //.netFramWork1.0委托。--函数指针
            deleTransfer trans = new deleTransfer(ToPascal);//委托指向方法topascal
            Console.WriteLine(trans("asdhasdh"));

ToPascal（）方法见上面代码中的ToPascal（this string s）代码

.net FrameWork2.0匿名方法代码：

            //net framework 2.0匿名方法
            deleTransfer trans = delegate(string s)

            { return s.Substring(0, 1).ToUpper() + s.Substring(1).ToLower(); };  //与1.0不同的地方

个人理解为其实也是一种委托。

Lambda的表达式：

            //net framework 3.5匿名方法
            deleTransfer trans = s => s.Substring(0, 1).ToUpper() + s.Substring(1).ToLower();
            Console.WriteLine(trans("ashadfh"));

我们可以从代码中看的出来，它在委托和匿名方法的基础上形成的Lambda语法。

Linq Lambda表达式可与查询操作符结合使用以代替委托。Linq Lambda表达式是创建委托实现的简略表达形式，并可用于匿名委托适用的所有场合。就是说是匿名方法和委托的进化来的，但不同的原因在参数里面，匿名方法中的参数必须是一顶一的，而Lambda是可以推断的。

我们写个例子：

            //Linq to Object
            //泛型集合数据persons
            List<string> persons = new List<string>();
            persons.Add("zhang san");
            persons.Add("awang san");
            persons.Add("zasdf san");
            persons.Add("sdfh san");
            persons.Add("dfh san");
            persons.Add("sdfgj san");
            persons.Add("sdfh san");
            persons.Add("zhang san");

           //输出person中所有的元素
            var result = persons.Select(p => p);
            result.Print();


        //为IEnumerable<string>提供输出的方法
        public static void Print(this IEnumerable<string> ie)
        {

            IEnumerator<string> result = ie.GetEnumerator();
            Console.WriteLine("\n------------------------\n");
            while(result.MoveNext())
            {
                Console.WriteLine(result.Current);
            }
            Console.WriteLine("\n------------------------\n");
        }

上面应用了Lambda表达式输出了person中所有的元素

我们应用一下Lambda表达式输出Person是中姓zhang的人：

方法一：

             //输出person中的姓zhang的人
           var result = persons.Where(p => p.StartsWith("zhang"));//直接查询
           result.Print();

方法二：

           var result = persons.Select(p=>p).Where(p => p.StartsWith("zhang"));//选出所有的之后，在选择查询。
           result.Print();

方法三：

           var result = persons.Where(p => p.StartsWith("zhang")).Select(p => p);//首先选出来后，再查询全部。三种方式都是可以的.
           result.Print();

我们看到的这三种方法都是可以的，就是顺序不同。可见其灵活性。

我们将下面的代码拿出来，因为几个地方都用到了它，我们可以提取出来，达到复用：

 p.StartsWith("zhang")

代码：

           var result = persons.Where(p => Judge(p)).Select(p => p);//可以将这个抽象出来，因为返回值是一个boolean值。
            result.Print();



        public bool Judge(string s)
        {
            if (s.StartsWith("zhang"))
            {
                return true;
            }
            else {
                return false;
            }
        }

从上面我们用到了Select 和Where语法，下篇博客将将会介绍lINQ的其他方法。