LINQ查询表达式---------from子句

LINQ查询表达式---------from子句

LINQ的查询由3基本部分组成：获取数据源，创建查询，执行查询。

//1、获取数据源
List<int> scores = new List<int> { , , , , ,  };

//创建查询
var scoreeQuery =
    from score in scores
    where score >
    select score;

//3、执行查询
foreach (int i in scoreeQuery)
{
    Console.WriteLine("{0}", i);
}

1.1 单个from子句

string[] values = { "张三", "李四", "王五", "大王", "小王" };
//查询所有包含“王”字的字符串
var valuesQuery = from v in values
                  where v.IndexOf("王") > -
                  select v;
foreach (string s in valuesQuery)
{
    Console.WriteLine(s);
}

输出结果：
    王五
    大王
    小王

在这个LINQ表达式的from子句中，v叫做范围变量，values是数据源。v的作用域存在于当前的LINQ表达式，表达式以外不能访问这个变量。where用来筛选元素，select用于输出元素。

1.2 复合from子句

public void ExpDemo()
{
    List<PerInfo> listPer = new List<PerInfo>
    {
        new PerInfo{
            Name = "小白",
            Age = ,
            Tel = new List<string>{"1535010****", "153****8523"}
        },
        new PerInfo{
            Name = "小新",
            Age = ,
            Tel = new List<string>{"1330708****", "1330709****"}
        },
        new PerInfo{
            Name = "小军",
            Age = ,
            Tel = new List<string>{"1380524****", "1380525****"}
        }
    };

    var query = from PerInfo p in listPer
                from listTel in p.Tel
                where listTel.IndexOf("1535010****") > -
                select p;

    foreach (var q in query)
    {
        Console.WriteLine("姓名：{0};年龄：{1}", q.Name, q.Age);
        foreach (var tel in q.Tel)
        {
            Console.WriteLine("电话：{0}", tel);
        }
    }
}

public class PerInfo
{
    public string Name
    {
        get;
        set;
    }
    public int Age
    {
        get;
        set;
    }
    public List<string> Tel
    {
        get;
        set;
    }
}

输出结果：
姓名：小白;年龄：19
电话：1535010****
电话：153****8523　

在查询数据源中，属性是一个集合时，可以使用复合from子句对这个属性集合查询。比如，一个人，可能有多个手机号。

1.3 多个from子句连接　

static void Main(string[] args)
{
    //1.3 使用多个from子句执行联结
    List<PerInfo> listPer1 = new List<PerInfo>
    {
        new PerInfo{
            Name = "小白",
            Age = ,
            Tel = new List<string>{"1535010****"}
        },
        new PerInfo{
            Name = "小新",
            Age = ,
            Tel = new List<string>{"1330708****"}
        },
        new PerInfo{
            Name = "小军",
            Age = ,
            Tel = new List<string>{"1380524****"}
        }
    };

    List<PerInfo> listPer2 = new List<PerInfo>
    {
        new PerInfo{
            Name = "小日",
            Age = ,
            Tel = new List<string>{"1535010****"}
        },
        new PerInfo{
            Name = "小月",
            Age = ,
            Tel = new List<string>{"1330708****"}
        },
        new PerInfo{
            Name = "小明",
            Age = ,
            Tel = new List<string>{"1380524****"}
        }
    };

    var query1 = from lp1 in listPer1
                 from lp2 in listPer2
                 select new { lp1, lp2 };

    foreach (var s in query1)
    {
        Console.WriteLine("{0}  {1} ", s.lp1.Name, s.lp2.Name);
    }

    Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++");

    var query2 = from lp1 in listPer1
                 where lp1.Age >
                 from lp2 in listPer2
                 where lp2.Age >
                 select new{ lp1, lp2};

    foreach (var s in query2)
    {
        Console.WriteLine("{0}  {1} ", s.lp1.Name, s.lp2.Name);
    }

    Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++");

    var query3 = from lp1 in listPer1
                 from lp2 in listPer2
                 where lp2.Age >
                 select new{lp1, lp2 };

    foreach (var s in query3)
    {
        Console.WriteLine("{0}  {1} ", s.lp1.Name, s.lp2.Name);
    }

    Console.ReadLine();
}

输出结果：
小白  小日
小白  小月
小白  小明
小新  小日
小新  小月
小新  小明
小军  小日
小军  小月
小军  小明
+++++++++++++++++++++++++++++++++++++++++++
小新  小月
小新  小明
小军  小月
小军  小明
+++++++++++++++++++++++++++++++++++++++++++
小白  小月
小白  小明
小新  小月
小新  小明
小军  小月
小军  小明

复合 from 子句用于访问单个数据源中的内部集合。 不过，查询还可以包含多个可从独立数据源生成补充查询的 from 子句。 使用此技术可以执行某些类型的、无法通过使用 join 子句执行的联接操作。