Linq简单使用

• 简单使用
• from子查询
• 关联多个数据源
• 分组
• let 子句

• 查询对象（上例中为list变量）为IEnumerable<T>或IQueryable<T>类型
• 查询返回结果同样为IEnumerable<T>或IQueryable<T>类型

Linq 分为：Linq to objects、Linq to DataSets、Linq to SQL、Linq to Entities、Linq to XML五类。

简单使用

类型 查询变量 =
               from 临时变量 in 集合对象或数据库对象
               [where 条件表达式]
               [order by 条件]
               select 临时变量或临时变量中被查询的值
               [group by]

① 普通查询：

// 数据源
int[] arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

// Linq查询
var result =
    from item in arr    // 声明临时变量item，并说明其为数组arr中的元素，item
    where item > 4
    select item;        // 将查询结果（item）添加到result中

// 遍历Linq查询结果，实际上是“Linq查询”是伴随foreach执行的，即在foreach执行前“Linq查询”不会执行
foreach(int i in result)
{
    Console.Write(i);   //输出56789
}

② 查询并排序：

int[] arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

var result =
    from item in arr
    where item > 4
    orderby item descending // 降序排列
    select item;

foreach(int i in result) {
    Console.Write(i);       // 输出：98765
}

③ 类型转换：

int[] arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

var result =
    from item in arr
    where item > 4
    select string.Format("值：{0} ", item);   // 转化为String类型，并格式化

foreach(string i in result) {   // 变量i更改为string类型
    Console.Write(i);           // 输出“值：5 值：6 值：7 值：8 值：8 ”
}

④ 查询单一值：

int[] arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

int result0 = (from item in arr where item > 4 select item).Count();   // 整个语句被一堆()抱起来，统计数目
int result1 = (from item in arr where item > 4 select item).Max();   // 查询最大值

Console.WriteLine(result0); //输出：5
Console.WriteLine(result1); //输出：9

from子查询

class Program
{
    static void Main(string[] args)
    {
        // 创建一个类似二维数组的泛型变量arr，用于存储学生信息
        List arr = new List
            {
                new Student {name = "李宁", scores = new List{11, 12, 34} },
                new Student {name = "阿迪", scores = new List{11, 16, 34} },
                new Student {name = "耐克", scores = new List{18, 12} },
            };

        // 查询学生分数大于15分的记录
        var result =
                from stu in arr             // 声明临时变量stu
                    from sc in stu.scores   // 声明临时变量sc用于“子查询”，
                where sc > 15
                select new {name = stu.name, score = sc};    // 将查询结果“投影”到一个新的对象中，该对象有name和score两个属性。

        foreach (var s in result) {
            Console.WriteLine(s.name + "：" + s.score);
        }
    }
}
class Student
{
    public string name;         // 学生姓名
    public List scores;    // 学生分数，一个学生可以有多个分数
}

输出结果：

李宁：34
阿迪：16
阿迪：34
耐克：18

上述示例，实际是每个学生都与其分数做了多次关联，并将查询结果存入新的对象（new {...}）中。

关联多个数据源

// 定义数据源
char[] upper = { 'A', 'B', 'C' };
char[] lower = { 'x', 'y', 'z' };

// 关联两个数据源
var result0 =
    from up in upper
    from lo in lower
    select new {upper = up, lower=lo};

foreach (var item in result0) {
    Console.WriteLine(item.upper + " " + item.lower);
}

// 关联两个数据源，并按条件筛选
var result1 =
    from up in upper
    from lo in lower
    where up != 'B'
    select new { upper = up, lower = lo };

foreach (var item in result1) {
    Console.WriteLine(item.upper + " " + item.lower);
}

两次输出结果分别为：

分组

① 简单分组

class Program
{

    static void Main(string[] args)
    {
        // 定义数据源
        List<Product> arr = new List<Product>
            {
                new Product{name = "衬衫", price = 13.9m, cid = 1},
                new Product{name = "短裤", price = 199.2m, cid = 1},
                new Product{name = "奥迪", price = 1.6m, cid = 2},
                new Product{name = "奔驰", price = 2.7m, cid = 2},
                new Product{name = "歼十", price = 82.3m, cid = 3},
                new Product{name = "播音", price = 91.3m, cid = 3},
            };

        var result =
            from p in arr
            group p by p.cid;

        // 遍历组别
        foreach (var gp in result) {
            Console.WriteLine("==============");
            // 遍历每组成员
            foreach (var pd in gp) {
                Console.WriteLine("{0}-{1}-{2}", pd.name, pd.price, pd.cid);
            }
        }

        Console.Read();
    }
}
class Product
{
    public string name;     // 商品名称
    public decimal price;   // 商品价格
    public int cid;         // 商品分类
}

此处的分组并非SQL中的分组，SQL中的分组主要用于分组统计。而此处的分组是将原来“一维的数据”按照一定规则分组成“二维的数据”，其输出结果：

② 对组对象处理

    static void Main(string[] args)
    {
        // 定义数据源
        List arr = new List
            {
                new Product{name = "衬衫", price = 13.9m, cid = 1},
                new Product{name = "短裤", price = 199.2m, cid = 1},
                new Product{name = "奥迪", price = 1.6m, cid = 2},
                new Product{name = "奔驰", price = 2.7m, cid = 2},
                new Product{name = "歼十", price = 82.3m, cid = 3},
                new Product{name = "播音", price = 91.3m, cid = 3},
            };
        List classList = new List
            {
                new Pclass{cname="衣服", cid = 1},
                new Pclass{cname="汽车", cid = 2},
                new Pclass{cname="飞机", cid = 3},
            };

        var result =
            from p in arr
            // G实际上就是组，格式为<Vey, Values>格式
            // Key为该分组的cid
            // Values为该组元素集合
            group p by p.cid into G

            from cls in classList
            where G.Key == cls.cid  // 关联组G和classList集合
            select new {cname = cls.cname, cid = cls.cid, gplist = G};

        foreach (var gp in result)
        {
            Console.WriteLine();
            Console.WriteLine("组名：{0}，分类id：", gp.cname, gp.cid);
            foreach (var pd in gp.gplist)
            {
                Console.WriteLine("{0}-{1}-{2}", pd.name, pd.price, pd.cid);
            }
        }
    }
}
class Pclass
{
    public int cid;         // 分类id
    public string cname;    // 分类名称
}
class Product
{
    public string name;     // 商品名称
    public decimal price;   // 商品价格
    public int cid;         // 商品分类
}

上述代码的关键在于对“into G”的理解，查询部分的执行过程为：
    第一步执行分组，分出一个组（如cid=1组）后存入临时变量G中；然后执行第二步，将该分组G与classList集合关联，将符合条件的结果按照select指定格式存储。第一个分组处理完毕后，按照上述步骤处理第二个分组（cid=2），依次类推。

程序执行输出结果：

③对分组对象进行删除

static void Main(string[] args)
{
    List sts = new List
        {
            new Student{id= 1, name="李宁", cid = 1},
            new Student{id= 2, name="李娜", cid = 2},
            new Student{id= 3, name="耐克", cid = 3},
            new Student{id= 4, name="阿迪", cid = 2},
            new Student{id= 5, name="奔驰", cid = 1},
            new Student{id= 6, name="报名", cid = 3},
        };    

    var result =
        from s in sts
        group s by s.cid into G
        select new {
            id = G.Key,
            list = (
                // 排除id为偶数的学生
                from m in G
                where (m.id % 2 != 0)
                select m
            )
        };

    foreach (var item in result) {
        Console.WriteLine("Cid：{0}", item.id);
        foreach (var s in item.list) {
            Console.WriteLine("{0}-{1}-{2}", s.id, s.name, s.cid);
        }
    }
}

let 子句

用于在查询中创建一个新的临时变量

static void Main(string[] args)
{
    // 定义数据源
    List sts = new List
        {
            new Student{id= 1, name="李宁", cid = 1},
            new Student{id= 2, name="李娜", cid = 2},
            new Student{id= 3, name="耐克", cid = 3},
            new Student{id= 4, name="阿迪", cid = 2},
            new Student{id= 5, name="奔驰", cid = 1},
            new Student{id= 6, name="报名", cid = 3},
        };

    var result =
        from s in sts
        let fullname = s.id + s.name
        select string.Format("id：{0},全称：{1}", s.id, fullname);

    foreach (string i in result) {
        Console.WriteLine(i);
    }
}