LINQ-from多from

简：

　　LINQ全称是Language  Integrated Query，中文“语言集成查询”。LINQ是一种查询技术，有LINQ toSQL、LINQ to Object、

LINQ to ADO.Net、LINQ to XML、 LINQ to EF等。

LINQ与直接SQL语句比较：

　　1.SQL数据库技术是一门相对比较复杂深奥的技术，不是人人都懂，而LINQ to SQL比较简单（实际上底层都对数据库操作进行了

封装，架构了数据访问层）

　　2.直接写SQL语句，如果有问题，只有到运行时才知道。

　　3.LINQ to SQL可以很好的防止注入攻击

　　4.LINQ是面向对象的查询，主要在程序内部使用（比如查找所需要的数据），比使用DataReader读取数据等方便多了；直接写

SQL是面向关系型数据库的查询。

　　5.从运行效率上来说性能不如直接SQL语句，但是开发效率提高了。

 

要学习LINQ首先要学习LINQ查询表达式。

　　LINQ的查询有3个基本部分组成；获取数据源，创建查询，执行查询

　　

        static void Main(string[] args)
        {
            //【1】获取数据源
            List<int> s = new List<int>() { 1,2,5,88,9,4,55,3};
            //【2】创建查询
            var number = from num in s
                         where num % 2 == 0
                         select num * 10;
            //与SQL语句比较下
            //select * from s where id%2==0
            //【3】执行查询
            foreach (var item in number)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
        }

在LINQ中，查询的执行与查询本身截然不同，换句话说，如果只是创建查询变量，则不会检索任何数据。

LINQ的数据源药酒必须实现IEnumerable<T>接口，数组隐士支持这个接口，number叫做查询变量，它存储了一个查询表达式

注意，声明查询变量并不会执行查询，真正的执行查询延迟到了Foreach语句中。    

查询表达式必须以From子句开头，以select或Group 子句结束。第一个from子句和最后一个select子句或Group子句之间，可以包含一个

或多个where子句、let子句、join子句、orderBy子句和Group子句，甚至还可以是From子句，它包括8个基本子句，具体如下：

• from子句：执行查询操作的数据源和范围变量。
• select子句：指定查询结果的类型和表现形式。
• where子句：指定筛选元素的逻辑条件。
• let子句：引入用来临时保存查询表达式中的子表达式结果的范围变量。
• orderby子句：对查询结果进行排序操作，包括升序和降序
• group子句：对查询结果进行分组。
• into子句：提供一个临时标识符。join、group或select子句可以通过该标识符引用查询操作中的结果。
• join子句：连接国歌用于查询操作的数据源。

 

From子句

　　创建一个LINQ表达式必须要以from子句开头。

　　例子1：单个from子句

　　

 static void Main(string[] args)
        {
            string[] values = { "中","日本","韩国","美国"};

            var sum = from a in values
                                //第一个匹配的字符
                      where a.IndexOf("国")>0
                      select a;

            foreach (var item in sum)
            {
                Console.WriteLine(item);
                Console.ReadKey();
            }
        }

在这个LINQ表达式的from子句中，a叫做范围变量，values是数据源。a的作用于存在于当前的LINQ表达式，表达式以外不能访问这个变量，

where 用来筛选元素，select 用于输出元素。这里的范围变量a和foreach语句中的隐士变量item都可以由编辑器推断出其类型。

 

例子2复合from子句

　　在查询数据源中，元素的属性是一个集合时，可以使用复合from子句对这个属性集合查询

 

  static void Main(string[] args)
        {
            //【1】创建数据源
            List<Custom> cut = new List<Custom>()
            {
                new Custom { name="杜伟",Age=30,Table=new List<string> { "1316685*****","1764408*****"} },
                new Custom { name="于海燕",Age=35,Table=new List<string> {"123456****","125458****" } }
                
            };
            //【2】创建linq表达式
            var telphone = from a in cut
                           from tel in a.Table    //因为电话又是一个集合。
                           where tel.IndexOf("1316685*****") > -1
                           select a;

            //【3】查询
            foreach (var item in telphone)
            {
                Console.WriteLine("姓名{0},年龄{1}",item.name,item.Age);
                //Table是一个泛型集合，也需要循环输出
                foreach (var tel in item.Table)
                {
                    Console.WriteLine("电话：{0}",tel);
                }
                    
            }
            Console.ReadKey();
        }

 多个from子句

　　

        static void Main(string[] args)
        {
            int[] a = { 12,4,53,48,11};
            int[] b = { 22,55,8,99,16};

            var intsum = from query in a
                         from query2 in b  //相当于一个嵌套查询
                         select query + query2;

            foreach (var item in intsum)
            {
                Console.WriteLine(item);
                //输出的结果不是对应的相加，而是a数组中每个元素根b数组中每个元素相加
                //34 67 20 111 28 26 59 ........等
            }
            Console.ReadKey();
        }