当前位置： 移动技术网 > IT编程>开发语言>c# > C# 基础知识系列- 8 Linq最后一部分查询表达式语法实践

C# 基础知识系列- 8 Linq最后一部分查询表达式语法实践

2020年04月09日  | 移动技术网IT编程  | 我要评论

1 前言

之前的几篇文章介绍了lambda和linq的一些支持方法。这一篇我尝试通过模拟具体的业务场景来描述一下linq的两种查询方式的使用。

一直提的linq查询方式分为两种，一种就是方法链的形式，官方的称呼是流式查询；另一种是类似于sql语句的查询方式，我之前叫做类sql查询方式，不过有的文档称之为查询表达式。
注意，本篇内容需要先看过 《c# 基础系列-7》，并有一定的对象和集合的基础。

1.1 数据准备：

因为这篇内容会涉及到多个数据源，所以这里需要准备一些类和数据，以下数据纯属虚构，不涉及到现实。

/// <summary>
/// 学生
/// </summary>
public class student
{
    /// <summary>
    /// 学号
    /// </summary>
    public long studentid { get; set; }
    /// <summary>
    /// 姓名
    /// </summary>
    public string name { get; set; }
    /// <summary>
    /// 年龄
    /// </summary>
    public int age { get; set; }
    /// <summary>
    /// 班级
    /// </summary>
    public string class { get; set; }
}
/// <summary>
/// 科目
/// </summary>
public class subject
{
    /// <summary>
    /// 
    /// </summary>
    public long subjectid { get; set; }
    /// <summary>
    /// 名称
    /// </summary>
    public string name { get; set; }
    /// <summary>
    /// 年级
    /// </summary>
    public string grade { get; set; }
    /// <summary>
    /// 教师
    /// </summary>
    public string teacher { get; set; }
}

/// <summary>
/// 考试
/// </summary>
public class exam
{
    /// <summary>
    /// 考试编号
    /// </summary>
    public long examid { get; set; }
    /// <summary>
    /// 科目编号
    /// </summary>
    public long subjectid { get; set; }
    /// <summary>
    /// 学生编号
    /// </summary>
    public long studentid { get; set; }
    /// <summary>
    /// 分数
    /// </summary>
    public double score { get; set; }
    /// <summary>
    /// 考试时间：年-月 如202004 表示2020年04月
    /// </summary>
    public int time { get; set; }
}

数据源：

list<student> students = new list<student>();// 学生列表，忽略数据来源
list<subject> subjects = new list<subject>();// 科目列表，忽略数据来源
list<exam> exams = new list<exam>();// 考试列表，忽略数据来源

2 查询演示

预先介绍一个概念，c#中有一种类型叫做匿名类型。因为c#的要求是万物皆对象，对象皆有类，所以每一个对象或者数据都是有类型在背后支撑的。但是有时候会需要一些一次性的只读类型，这时候声明一个完整的类就有点得不偿失了。什么是一次性的只读类型呢，就是我们只关心它有哪些属性，不关心它有什么方法，同时这个类对应的对象只能在初始化的时候给属性赋值其他时候不能重新赋值，而且这个类型只在方法内部使用，在这个变量使用完成之后这个类型也失去了意义，这种类型就是我们所说的一次性的只读类型。

那么这种类型怎么声明呢？先不急，先再介绍一个关键字var。这个关键字有什么特别的地点吗？var 表示隐式“类型”，意思就是用var声明的变量其类型需要编译器自己结合上下文推断，也就是说使用者和声明者都知道这个变量的类型，但是没有明说。

那么为什么需要介绍var呢？原因在于，var 是匿名对象的基础。因为匿名对象不能用object声明变量，原因有两点，第一，变量声明为object之后，我们所需要的属性就无法使用了；第二，匿名类型的对象无法直接类型转换为object。所以，想要正常使用匿名类型，必须用var。

下面简单演示一下匿名类型的声明和使用：

var obj = new 
{
    name = "萧三",
    age = 20
};
// obj.name 萧三
// obj.age 20

这就是匿名类型，声明了一个有name和age属性的对象，这个对象我们知道它有哪些属性，但是不知道它的类型是什么。

在介绍完需要的知识后，将通过实际的情况来比较一下流式查询和查询表达式两种写法。

2.1 简单查询

  1. 查询班级是三年一班的所有同学

    // 流式查询
var results = students.where(t=>t.class=="三年一班");
// 查询表达式
var results = from s in students
    where s.class == "三年一班"
    select s;

    这两种查询方式结构都是ienumerable<t>。

  2. 获取姓张的所有学生的花名册

    // 流式查询
var results = students.where(t=>t.name.startwith("张"));
// 查询表达式
var results = from s in students where s.name.startwith("张") select s;

  3. 按班级进行分组获取每个班的学生花名册

    // 流式查询
var results = students.groupby(t => t.class);
// 查询表达式
var results = from s in students group s by s.class;
// 注明：完整的写法如下：
// var results = from s in students group s by s.class into g select g;

    需要注意的是，如果返回结果是一个分组的结果，那么就不用select了。

  4. 查询每个班的平均年龄

    // 流式查询
var results = students.groupby(t => t.class)
                .select(t => new {class = t.key, aveage = t.average(p => p.age)});
// 查询表达式
var results = from s in students
                group s by s.class
                into g
                select new {class = g.key, aveage = g.average(t => t.age)};

    查询表达式中没有统计查询的相关关键字，只能通过方法来获取，同时查询表达式返回的是一个集合，所以没法直接通过查询表达式进行求和、求平均等。

  5. 对所有学生按照年龄大小从大到小进行排序

    // 流式查询
var results = students.orderbydescending(t => t.age);
// 查询表达式
var results = from s in students orderby s.age descending select s;

  6. 对所有学生按照年龄大小从小到大进行排序

    // 流式查询
var results = students.orderby(t => t.age);
// 查询表达式
var results = from s in students orderby s.age select s;

  7. 先按年龄排序再按姓名进行排序

    // 流式查询
var results = students.orderby(t => t.age).thenby(t=>t.name);//thenbydescending 是降序版的thenby
// 查询表达式
var results = from s in students orderby s.age //descending 如果是降序则增加这个关键字
    , s.name select s;

2.2 复杂查询

前一部分介绍了简单的查询，这一部分介绍联合多个数据源进行一系列的查询操作。

  1. 查询三年级语文科目在202004月举行的考试的所有成绩

    // 流式查询
var results = subjects.join(exams, s => s.subjectid, e => e.studentid, (s, e) => new
{
    s.name,
    s.grade,
    e.score,
    e.time
}).where(t=>t.grade == "三年级" && t.name =="语文" && t.time == 202004).select(t=>t.score);
// 查询表达式
var results = from s in subjects
                join e in exams on s.subjectid equals e.subjectid
                where e.time == 202004 && s.grade == "三年级" && s.name == "语文"
                select e.score;

  2. 按年级进行分组，查询各年级语文分数

    // 流式查询
var results = subjects.where(p => p.name == "语文")
                .join(exams, s => s.subjectid, e => e.subjectid, (s, e) => new {s.grade, e.score})
                .groupby(t => t.grade);
// 查询表达式
var results = from s in subjects
                join e in exams on s.subjectid equals e.subjectid
                where s.name == "语文"
                group e.score by s.grade
                into g
                select g;

  3. 求各年级历次考试各科目分数的平均分和最高分以及最低分

    //流式查询
var results = subjects.join(exams, s => s.subjectid, e => e.subjectid, (s, e) => new
            {
                s.grade,
                s.name,
                e.score
            }).groupby(t => t.grade).select(t => new
            {
                grade = t.key,
                subjects = t.groupby(p => p.name).select(p => new
                {
                    name = p.key,
                    max = p.max(r => r.score),
                    min = p.min(r => r.score),
                    average = p.average(r => r.score)
                })
            });
//查询表达式
var results = from s in subjects
                join e in exams on s.subjectid equals e.subjectid
                let o = new {s.grade, s.name, e.score}
                group o.score by new {o.grade, o.name}
                into o
                let p = new
                {
                    o.key.grade, subject = new {o.key.name, 
                                                max = o.max(),
                                                min = o.min(), 
                                                average = o.average()}
                }
                group p.subject by p.grade
                into g
                
                select new
                {
                    grade = g.key,
                    subjects = g.asenumerable()
                };

    以上大概介绍了一下linq的使用，明显可以看得出，流式查询和查询表达式在可读性上区别还是蛮大的。对于熟悉sql的人，查询表达式能更快的上手；对于我来说，更习惯于用流式查询，不过在多数据源联合的时候，我更倾向于写查询表达式。以上是基础篇linq的全部内容。

更多内容烦请关注

file

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网