1. Toy模板网首页
  2. > Toy博客

（十一）CSharp-LINQ-查询表达式（2）

7月前 作者：CRongQ 分类：Toy博客 阅读(35) 违法举报

这篇具有很好参考价值的文章主要介绍了（十一）CSharp-LINQ-查询表达式（2）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、查询表达式

1、查询表达式的结构

查询表达式由 from 子句和查询主体组成。

  • 子句必须按照一定的顺序出现。
  • from 子句和 select…group 子句这两部分是必需的。
  • 其他子句是可选的。
  • 在 LINQ 查询表达式中，select 子句在表达式最后。
  • 可以有任意多的 from…let…where 子句。

（十一）CSharp-LINQ-查询表达式（2）

2、from 子句

from 子句指定了要作为数据源使用的数据集合。它还引入了迭代变量。

要点：

  • 1）迭代变量逐个表示数据源的每一个元素。

  • 2）from 子句的语法如下：

    • Type 是集合中元素的类型。这是可选的，因为编译器可以从集合中推断类型。
    • Item 是迭代变量的名字。
    • Items 是要查询的集合的名字。集合必须是可枚举的。
from Type Item in Items
//迭代变量声明：Type Item in Items

int arr1 = {10,11,12,13};

var query = from item in arr1
		    where item < 13
		    select item;

foreach(var item in query)
Console.Write($"{ item },");
//迭代变量：item

输出结果：

10,11,12,

图演示了 from 子句的语法

（十一）CSharp-LINQ-查询表达式（2）

LINQ 的 from 子句和 foreach 语句非常相似，但主要的不同点如下：

  • foreach 语句命令式地制定了要从第一个到最后一个按顺序访问集合中的项。而 from 子句则声明式地规定集合中的每个项都要被访问，但并没有假定以什么样的顺序。

  • foreach 语句在遇到代码时就执行其主体，而 from 子句什么也不执行。它创建可以执行查询的后台代码对象。只有在程序的控制流遇到访问查询变量的语句时，才会执行查询。

3、join 子句

有关联结的要点：

  • 使用联结来结合两个或更多集合中的数据。
  • 联结操作接受两个集合，然后创建一个临时的对象集合，其中每一个对象包含两个原始集合对象中的所有字段。

联结的语法如下，它指定了第二个集合要和之前子句中的集合进行联结：

join Identifier in Collection2 on Field1 equals Field2
//关键字：join、in、on、equals
//指定另外的集合和 ID 来引用它：Identifier in Collection2
//用于比较相等性的字段：Field1 equals Field2

图20-4演示了 join 子句的语法：

（十一）CSharp-LINQ-查询表达式（2）

join 子句的示例

var query = from s in students
			join c in studentsInCourses on s.StID equals c.StID

//第一个集合和 ID：from s in students
//第二集合和 ID：c in studentsInCourses
//第一个集合的项：s.StID
//第二集合的项：c.StID

什么是联结

LINQ 中的 join 接受两个集合，然后创建一个新的集合，其中每一个元素包含两个原始集合中的元素成员。

public class Student
{
public int StID;
public string LastName;
}

public class CourseStudent
{
public string CourseName;
public inr StID;
}

如图所示：
Student 对象为 students，CourseStudent 对象为 studentsInCourses。

（十一）CSharp-LINQ-查询表达式（2）

*图20-6演示了联结是如何工作的。

如果我们拿第一个学生的记录并把它的 ID 和每一个 studentsInCourses 对象中的学生 ID 进行比较，可以找到两条匹配的记录，中间列的顶部就是。

（十一）CSharp-LINQ-查询表达式（2）

示例：


    class Program
    {
        public class Student
        {
            public int StID;
            public string LastName;
        }

        public class CourseStudent
        {
            public string CourseName;
            public int StID;
        }

        static Student[] students = new Student[]
        {
            new Student { StID = 1, LastName = "Carson" },
            new Student { StID = 2, LastName = "Klassen" },
            new Student { StID = 3, LastName = "Fleming" },

        };

        static CourseStudent[] studentsInCourses = new CourseStudent[]
        {
            new CourseStudent { CourseName = "Art",     StID = 1 },
            new CourseStudent { CourseName = "Art",     StID = 2 },
            new CourseStudent { CourseName = "History",     StID = 1 },
            new CourseStudent { CourseName = "History",     StID = 3 },
            new CourseStudent { CourseName = "Physics",     StID = 3 },
        };

        static void Main(string[] args)
        {
            var query = from s in students
                        join c in studentsInCourses on s.StID equals c.StID
                        where c.CourseName == "History"
                        select s.LastName;

            foreach (var q in query)
                Console.WriteLine($"Student taking History: { q }");
                             
            Console.ReadKey();
        }
    }

输出结果：

Student taking History: Carson
Student taking History: Fleming

4、查询主体中的 from…let…where 片段

可选的 from…let…where 部分是查询主体的第一部分，可以由任意数量的3种子句构成—— from 子句、let 子句和 where 子句。

1）from 子句

查询表达式从必需的 from 子句开始，后面跟的是查询主体。主体本身可以从任何数量的其他 from 子句开始，每一个 from 子句都指定了一个额外的源数据集合并引入了要在之后运算的迭代变量。

（十一）CSharp-LINQ-查询表达式（2）

示例：

      static void Main(string[] args)
        {
            var groupA = new[] { 3, 4, 5, 6 };
            var groupB = new[] { 6, 7, 8, 9 };

            var someInts = from a in groupA//必需的第一个 from 子句
                           from b in groupB//查询主体的第一个子句
                           where a > 4 && b <= 8
                           select new { a, b, sum = a + b };//匿名类型对象

            foreach (var x in someInts)
                Console.WriteLine(x);

            Console.ReadKey();
        }

输出结果：

{ a = 5, b = 6, sum = 11 }
{ a = 5, b = 7, sum = 12 }
{ a = 5, b = 8, sum = 13 }
{ a = 6, b = 6, sum = 12 }
{ a = 6, b = 7, sum = 13 }
{ a = 6, b = 8, sum = 14 }

2）let 子句

let 子句接受一个表达式的运算并且把它赋值给一个需要在其他运算种使用的标识符。

let 子句的语法如下：

let Identifier = Expression

示例：

static void Main(string[] args)
        {
            var groupA = new[] { 3, 4, 5, 6 };
            var groupB = new[] { 6, 7, 8, 9 };

            var someInts = from a in groupA
                           from b in groupB
                           let sum = a + b //在新的变量中保存结果
                           where sum == 12
                           select new { a, b, sum};

            foreach (var x in someInts)
                Console.WriteLine(x);

            Console.ReadKey();
        }

输出结果：

{ a = 3, b = 9, sum = 12 }
{ a = 4, b = 8, sum = 12 }
{ a = 5, b = 7, sum = 12 }
{ a = 6, b = 6, sum = 12 }

3）where 子句

==where 子句根据之后的运算来去除不符合指定条件的项目。==where 子句如下：

where BooleanExpression

有关 where的要点：

  • 只要是在 from…let…where 部分中，查询表达式可以有任意多个 where 子句。
  • 一个项必须满足所有 where 子句才能避免在之后被去除。
    static void Main(string[] args)
        {
            var groupA = new[] { 3, 4, 5, 6 };
            var groupB = new[] { 6, 7, 8, 9 };

            var someInts = from a in groupA
                           from b in groupB
                           let sum = a + b 
                           where sum >= 11//条件1
                           where a == 4 //条件2
                           select new { a, b, sum };

            foreach (var x in someInts)
                Console.WriteLine(x);

            Console.ReadKey();
        }

输出结果：

{ a = 4, b = 7, sum = 11 }
{ a = 4, b = 8, sum = 12 }
{ a = 4, b = 9, sum = 13 }

二、orderby 子句

orderby 子句接受一个表达式并根据表达式按顺序返回结果项。

可选的 ascending 和 descending 关键字设置了排序方向。表达式通常是项的一个字段。该字段不一定非得是数值字段，也可以是字符串这样的可排序类型。

  • orderby 子句的默认排序是升序。然后，我们可以使用 ascending 和 descending 关键字显式地设置元素的排序为升序或降序。
  • 可以有任意多个子句，它们必须使用逗号分隔。
       static void Main(string[] args)
        {
            var students = new[]
            {
              new { LName = "Jones", FName = "Mary" , Age = 19, Major = "History" },
              new { LName = "Smith", FName = "Bob" , Age = 20, Major = "CompSci" },
              new { LName = "Fleming", FName = "Carol" , Age = 21, Major = "History" },
          };

            var query = from student in students
                        orderby student.Age//根据年龄排序
                        select student;

            foreach (var s in query)
                Console.WriteLine($"{ s.LName },{ s.FName },{ s.Age },{ s.Major }");

            Console.ReadKey();
        }

输出结果：

Jones,Mary,19,History
Smith,Bob,20,CompSci
Fleming,Carol,21,History

三、select…group 子句

select…group 部分由两种类型的子句组成——select 子句和 group…by 子句。select…group 部分之前的子句指定了数据源和要选择的对象。

select…group 部分的功能如下：

  • 1）==select 子句指定应用选择所选对象的哪些部分。==它可以指定下面的任意一项。

    • 整个数据项。
    • 数据项的一个字段。
    • 数据项中几个字段组成的新对象。（或类似其他值）

  • 2）group…by 子句是可选的，用来指定选择的项如何被分组。

示例：

       static void Main(string[] args)
        {
            var students = new[]
            {
              new { LName = "Jones", FName = "Mary" , Age = 19, Major = "History" },
              new { LName = "Smith", FName = "Bob" , Age = 20, Major = "CompSci" },
              new { LName = "Fleming", FName = "Carol" , Age = 21, Major = "History" },
          };

            var query = from s in students
                        select s;

            foreach (var q in query)
                Console.WriteLine($"{ q.LName },{ q.FName },{ q.Age },{ q.Major }");

            Console.ReadKey();
        }

输出结果：

Jones,Mary,19,History
Smith,Bob,20,CompSci
Fleming,Carol,21,History

也可以使用 select 子句来选择对象的某些字段。

var query = from s in students
			select s.LName;

foreach(var q in query)
Console.WriteLine(q);

输出结果：

Jones
Smith
Fleming

四、查询中的匿名类型

查询结果可以由原始集合的项、原始集合中项的字段或匿名类型组成。

select new { s.LastNmae, s.FirstName, s.Major };

示例：

       static void Main(string[] args)
        {
            var students = new[]
            {
              new { LName = "Jones", FName = "Mary" , Age = 19, Major = "History" },
              new { LName = "Smith", FName = "Bob" , Age = 20, Major = "CompSci" },
              new { LName = "Fleming", FName = "Carol" , Age = 21, Major = "History" },
          };

            var query = from s in students
                        select new { s.LName, s.FName, s.Major };

            foreach (var q in query)
                Console.WriteLine($"{ q.LName },{ q.FName } -- { q.Major }");

            Console.ReadKey();
        }

//创建匿名类型：s.LName, s.FName, s.Major
//匿名类型的访问字段：q.LName、q.FName、q.Major

输出结果：

Jones,Mary – History
Smith,Bob – CompSci
Fleming,Carol – History

五、group 子句

group 子句根据指定的标准对选择的对象进行分组。

有关 group 子句的要点：

  • 如果项包含在查询的结果中，它们就可以根据某个字段的值进行分组。作为分组依据的属性叫键（key）。

  • group 子句返回的不是原始数据源中项的枚举，而是返回可以枚举已经形成的项的分组的可枚举类型。

  • 分组本身是可枚举类型，它们可以枚举实际的项。

group student by student.Majot;

示例：

      static void Main(string[] args)
        {
            var students = new[]
            {
              new { LName = "Jones", FName = "Mary" , Age = 19, Major = "History" },
              new { LName = "Smith", FName = "Bob" , Age = 20, Major = "CompSci" },
              new { LName = "Fleming", FName = "Carol" , Age = 21, Major = "History" },
          };

            var query = from student in students
                        group student by student.Major;

            foreach (var g in query)//枚举分组
            {
                Console.WriteLine("{0}", g.Key);

                foreach (var s in g)//枚举分组中的项
                    Console.WriteLine($"   { s.LName },{ s.FName }");
            }

            Console.ReadKey();
        }

//分组键：g.Key

输出结果：

History
Jones,Mary
Fleming,Carol
CompSci
Smith,Bob

图20-10演示了从查询表达式返回并保存于查询变量中的对象。

  • 从查询表达式返回的对象是从查询中枚举分组结果的可枚举类型。
  • 每一个分组由一个叫作键的字段区分。
  • 每一个分组本身是可枚举类型并且可以枚举它的项。

（十一）CSharp-LINQ-查询表达式（2）

六、查询延续：into 子句

查询延续子句可以接受查询的一部分的结果并赋予一个名字，从而可以在查询的另一部分中使用。

示例：

        static void Main(string[] args)
        {
            var groupA = new[] { 3, 4, 5, 6 };
            var groupB = new[] { 4, 5, 6, 7 };

            var someInts = from a in groupA
                           join b in groupB on a equals b
                           into groupAandB //查询延续
                           from c in groupAandB
                           select c;

            foreach (var v in someInts)
                Console.Write($"{ v } ");

            Console.ReadKey();
        }

输出结果：

4 5 6文章来源地址https://www.toymoban.com/news/detail-506941.html

到了这里，关于（十一）CSharp-LINQ-查询表达式（2）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • C# LINQ和Lambda表达式对照

    Linq语法： Lamda语法： sql语法： Linq语法： Lamda语法： sql语法： Linq语法： Lamda语法： sql语法： ​ Linq语法： Lamda语法： sql语法： ​ Linq语法： Lamda语法： sql语法： ​ Linq语法： Lamda语法： sql语法： Linq语法： Lamda语法： sql语法： ​ Linq语法： Lamda语法： EF Core中的写法：

    2024年02月16日
    浏览(30)

  • AI面试官：LINQ和Lambda表达式（三）

    当面试官面对C#中关于LINQ和Lambda表达式的面试题时，通常会涉及这两个主题的基本概念、用法、实际应用以及与其他相关技术的对比等。以下是一些可能的面试题目，附带简要解答和相关案例和代码： 解答：延迟执行是指LINQ查询在遍历结果之前不会立即执行，而是在实际需

    2024年02月16日
    浏览(24)

  • AI面试官：LINQ和Lambda表达式（一）

    当面试官面对C#中关于LINQ和Lambda表达式的面试题时，通常会涉及这两个主题的基本概念、用法、实际应用以及与其他相关技术的对比等。以下是一些可能的面试题目，附带简要解答和相关案例和代码： 解答：LINQ（Language Integrated Query）是一种在C#编程语言中集成的查询技术，

    2024年02月15日
    浏览(27)

  • AI面试官：LINQ和Lambda表达式（二）

    当面试官面对C#中关于LINQ和Lambda表达式的面试题时，通常会涉及这两个主题的基本概念、用法、实际应用以及与其他相关技术的对比等。以下是一些可能的面试题目，附带简要解答和相关案例和代码： 解答：Lambda表达式的闭包是指它可以访问其周围范围内的变量，即使这些变

    2024年02月16日
    浏览(28)
  • 十一、常用API——正则表达式

    十一、常用API——正则表达式

    目录 练习1：  正则表达式的作用 正则表达式 字符类（只匹配一个字符）  预定义字符（只匹配一个字符） 数量词 类 Pattern 正则表达式的构造摘要 反斜线、转义和引用 字符类 行结束符 组和捕获 Unicode 支持 与 Perl 5 相比较 练习2： 关于正则表达式可以使用插件生成  练习

    2024年01月19日
    浏览(69)

  • python笔记：第十一章正则表达式

    以一定规则，快速检索文本，或是实现一些替换操作 默认下，区分大小写 字符 描述 d 代表任意数字，就是阿拉伯数字 0-9 这些 D 代表非数字的字符。与d完全相反 w 代表字母，数字，下划线。也就是 a-z、A-Z、0-9、_ W 跟 w 相反 ，代表不是字母，不是数字，不是下划线的字

    2024年02月17日
    浏览(30)

  • （十一）CSharp-LINQ-LINQToXML（4）

    1、创建、保存、加载和显示 XML 文档 输出结果： 1）创建 XML 树 输出结果： 2）使用 XML 树的值 表20-2 查询 XML 的方法 方法名称 类 返回类型 描述 Nodes Xdocument,XElement IEnumerableobject 返回当前节点的所有节点（不管是什么类型） Elements Xdocument,XElement IEnumerableXElement 返回当前节点的

    2024年02月11日
    浏览(44)

  • 以对象的方式访问html中的标签，比正则表达式更好用的方式获取html中的内容，linq方式直接获取所有的链接，更加先进的c#版本爬虫开源库

    这是我本人自己写的一个开源库，现已经发布到nuget，可以直接在vs的nuget包管理中搜索到，或者可以到nuget官网下载：https://www.nuget.org/packages/ZmjConvert/，也可以到我的个人网站上下载源码：https://www.zhaimaojun.cn/P/C%23%e6%a0%87%e7%ad%be%e7%b1%bb%e6%96%87%e6%9c%ac%e5%ba%8f%e5%88%97%e5%8c%96%e5%ba%9

    2024年03月15日
    浏览(46)
  • 文本单词查询复合表达式求值的实现案例分析

    文本单词查询复合表达式求值的实现案例分析

            本文讨论的“ 文本单词查询复合表达式求值的实现 ”案例，来自C++ primer第四版，该案例面向对象编程和泛型编程， 涉及类的继承、抽象、多态、句柄、标准IO库、容器、算法库 ，是综合性很强的程序         该程序实现文本中查找单个单词，“非”查询（使

    2024年01月23日
    浏览(26)
  • JavaScript从入门到精通系列第三十一篇：详解JavaScript中的字符串和正则表达式相关的方法

    JavaScript从入门到精通系列第三十一篇：详解JavaScript中的字符串和正则表达式相关的方法

      文章目录 知识回顾 1：概念回顾 2：正则表达式字面量 一：字符串中正则表达式方法 1：split 2：search 3：match 4：replace         正则表达式用于定义一些字符串的规则，计算机可以根据正则表达式检查一个字符串是否符合规则，或者将字符串中符合规则的内容提取出来。

    2024年01月17日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包