LINQ(五)演练

最新推荐文章于 2021-06-06 22:57:11 发布
最新推荐文章于 2021-06-06 22:57:11 发布
阅读量416 收藏
点赞数
分类专栏： c#常用知识 文章标签： linq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/conganguo/article/details/40222389
版权


演练：用 C# 编写查询 (LINQ)

创建C# 项目

创建项目

1.    启动 VisualStudio。

2.    在菜单栏上，选择“文件”，“新建、“项目”。

将打开“新建项目”对话框。

3.    外接 已安装，展开 模板，展开 Visual C#，然后选择 控制台应用程序。

4.    在 名称 文本框中，输入一个不同的名称或接受默认名称，然后选择 确定 按钮。

新项目出现在“解决方案资源管理器”中。

5.    请注意，您的项目具有对 System.Core.dll的引用以及适用于 System.Linq 命名空间的 using 指令。

创建内存中数据源

查询的数据源是 Student 对象的简单列表。 每个 Student 记录都有名、姓和表示他们在班级中的测验分数的整数数组。 将此代码复制到您的项目。 请注意下列特性：

·        Student 类包含自动实现的属性。

·        列表中的每个学生都已使用对象初始值设定项进行初始化。

·        列表本身已使用集合初始值设定项进行初始化。

将在不显式调用任何构造函数和使用显式成员访问的情况下初始化并实例化整个数据结构。 有关这些新功能的更多信息，请参见自动实现的属性（C#编程指南）和对象和集合初始值设定项（C#编程指南）。

添加数据源

·        将 Student 类和经过初始化的学生列表添加到您的项目的 Program 类中。

C#

 
public class Student
{
    public string First { get; set; }
    public string Last { get; set; }
    public int ID { get; set; }
    public List<int> Scores;
}
 
// Create a data source by using a collection initializer.
static List<Student> students = new List<Student>
{
   new Student {First="Svetlana", Last="Omelchenko", ID=111, Scores= new List<int> {97, 92, 81, 60}},
   new Student {First="Claire", Last="O'Donnell", ID=112, Scores= new List<int> {75, 84, 91, 39}},
   new Student {First="Sven", Last="Mortensen", ID=113, Scores= new List<int> {88, 94, 65, 91}},
   new Student {First="Cesar", Last="Garcia", ID=114, Scores= new List<int> {97, 89, 85, 82}},
   new Student {First="Debra", Last="Garcia", ID=115, Scores= new List<int> {35, 72, 91, 70}},
   new Student {First="Fadi", Last="Fakhouri", ID=116, Scores= new List<int> {99, 86, 90, 94}},
   new Student {First="Hanying", Last="Feng", ID=117, Scores= new List<int> {93, 92, 80, 87}},
   new Student {First="Hugo", Last="Garcia", ID=118, Scores= new List<int> {92, 90, 83, 78}},
   new Student {First="Lance", Last="Tucker", ID=119, Scores= new List<int> {68, 79, 88, 92}},
   new Student {First="Terry", Last="Adams", ID=120, Scores= new List<int> {99, 82, 81, 79}},
   new Student {First="Eugene", Last="Zabokritski", ID=121, Scores= new List<int> {96, 85, 91, 60}},
   new Student {First="Michael", Last="Tucker", ID=122, Scores= new List<int> {94, 92, 91, 91} }
};
 
 

在学生列表中添加新学生

·        将新 Student 添加到 Students 列表中并使用您选择的姓名和测验分数。 尝试键入新学生的所有信息，以便更好地了解对象初始值设定项的语法。

创建查询

创建简单查询

·        在应用程序的 Main 方法中创建一个简单查询，执行该查询时，将生成第一次测验中分数高于 90 分的所有学生的列表。 请注意，由于选择了整个 Student 对象，因此查询的类型是IEnumerable<Student>。 虽然代码也可以通过使用 var 关键字来使用隐式类型，但这里使用了显式类型以便清楚地演示结果。 （有关 var 的更多信息，请参见隐式类型的局部变量（C#编程指南）。）

另请注意，该查询的范围变量 student 用作对源中每个 Student 的引用，以提供对每个对象的成员访问。

C#

 
// Create the query.
// The first line could also be written as "var studentQuery ="
IEnumerable<Student> studentQuery =
    from student in students
    where student.Scores[0] > 90
    select student;
 
 

执行查询

执行查询

1.    现在编写用于执行查询的 foreach 循环。 请注意有关代码的以下事项：

o    所返回序列中的每个元素是通过 foreach 循环中的迭代变量来访问的。

o    此变量的类型是 Student，查询变量的类型是兼容的 IEnumerable<Student>。

2.    添加此代码后，按Ctrl + F5生成并运行该应用程序，然后在“控制台”窗口中查看结果。

C#

 
// Execute the query.
// var could be used here also.
foreach (Student student in studentQuery)
{
    Console.WriteLine("{0}, {1}", student.Last, student.First);
}
 
// Output:
// Omelchenko, Svetlana
// Garcia, Cesar
// Fakhouri, Fadi
// Feng, Hanying
// Garcia, Hugo
// Adams, Terry
// Zabokritski, Eugene
// Tucker, Michael
 
 

添加另一个筛选条件

·        您可以在 where 子句中组合多个布尔条件，以便进一步细化查询。 下面的代码添加一个条件，以便查询返回第一个分数高于 90 分并且最后一个分数低于 80 分的那些学生。 where 子句应类似于以下代码。

·         where student.Scores[0] > 90 && student.Scores[3] < 80

有关更多信息，请参见where子句（C#参考）。

修改查询

对结果进行排序

1.    如果结果按某种顺序排列，则浏览结果会更容易。 您可以根据源元素中的任何可访问字段对返回的序列进行排序。 例如，下面的 orderby 子句根据每个学生的姓按从 A 到 Z 的字母顺序对结果进行排序。 紧靠在 where 语句之后、select 语句之前，将下面的 orderby 子句添加到您的查询中：

2.  orderby student.Last ascending

3.    现在更改 orderby 子句，以便根据第一次测验的分数的反向顺序，即从高分到低分的顺序对结果进行排序。

4.  orderby student.Scores[0] descending

5.    更改 WriteLine 格式字符串以便您可以查看分数：

6.  Console.WriteLine("{0}, {1} {2}", student.Last, student.First, student.Scores[0]);

有关更多信息，请参见orderby子句（C#参考）。

对结果进行分组

1.    分组是查询表达式中的强大功能。 包含 group子句的查询将生成一系列组，每个组本身包含一个Key 和一个序列，该序列由该组的所有成员组成。 下面的新查询使用学生的姓的第一个字母作为关键字对学生进行分组。

C#

 
// studentQuery2 is an IEnumerable<IGrouping<char, Student>>
var studentQuery2 =
    from student in students
    group student by student.Last[0];
 
 

2.    请注意，查询的类型现在已更改。 该查询现在生成一系列将 char 类型作为关键字的组，以及一系列 Student 对象。 由于查询的类型已更改，因此下面的代码也会更改 foreach 执行循环：

C#

 
// studentGroup is a IGrouping<char, Student>
foreach (var studentGroup in studentQuery2)
{
    Console.WriteLine(studentGroup.Key);
    foreach (Student student in studentGroup)
    {
        Console.WriteLine("   {0}, {1}",
                  student.Last, student.First);
    }
}
 
// Output:
// O
//   Omelchenko, Svetlana
//   O'Donnell, Claire
// M
//   Mortensen, Sven
// G
//   Garcia, Cesar
//   Garcia, Debra
//   Garcia, Hugo
// F
//   Fakhouri, Fadi
//   Feng, Hanying
// T
//   Tucker, Lance
//   Tucker, Michael
// A
//   Adams, Terry
// Z
//   Zabokritski, Eugene
 
 

3.    按 Ctrl +F5运行该应用程序并在“控制台”窗口中查看结果。

有关更多信息，请参见group子句（C#参考）。

隐式类型化变量

·        显式编写 IGroupings 的 IEnumerables 代码很快就会变得乏味。 通过使用 var，您可以更方便地编写相同的查询和 foreach 循环。 var 关键字不会更改对象的类型，它仅指示编译器推断类型。 更改 studentQuery 的类型和迭代变量的 group到 var 并重新运行查询。 请注意，在内部foreach 循环中，迭代变量仍然类型化为 Student，而查询仍可像以前一样工作。 将 s 迭代变量更改为 var 并再次运行查询。 您将看到完全相同的结果。

C#

 
var studentQuery3 =
    from student in students
    group student by student.Last[0];
 
foreach (var groupOfStudents in studentQuery3)
{
    Console.WriteLine(groupOfStudents.Key);
    foreach (var student in groupOfStudents)
    {
        Console.WriteLine("   {0}, {1}",
            student.Last, student.First);
    }
}
 
// Output:
// O
//   Omelchenko, Svetlana
//   O'Donnell, Claire
// M
//   Mortensen, Sven
// G
//   Garcia, Cesar
//   Garcia, Debra
//   Garcia, Hugo
// F
//   Fakhouri, Fadi
//   Feng, Hanying
// T
//   Tucker, Lance
//   Tucker, Michael
// A
//   Adams, Terry
// Z
//   Zabokritski, Eugene
 
 

有关 var 的更多信息，请参见隐式类型的局部变量（C#编程指南）。

按键值对组进行排序

·        当您运行前面的查询时，会注意到组没有按字母顺序排列。 若要改变这种情况，您必须在 group子句后提供 orderby 子句。 但要使用 orderby 子句，您首先需要一个标识符，用作对 group子句创建的组的引用。 可以使用 into 关键字来提供此标识符，如下所示：

C#

 
var studentQuery4 =
    from student in students
    group student by student.Last[0] into studentGroup
    orderby studentGroup.Key
    select studentGroup;
 
foreach (var groupOfStudents in studentQuery4)
{
    Console.WriteLine(groupOfStudents.Key);
    foreach (var student in groupOfStudents)
    {
        Console.WriteLine("   {0}, {1}",
            student.Last, student.First);
    }
}
 
// Output:
//A
//   Adams, Terry
//F
//   Fakhouri, Fadi
//   Feng, Hanying
//G
//   Garcia, Cesar
//   Garcia, Debra
//   Garcia, Hugo
//M
//   Mortensen, Sven
//O
//   Omelchenko, Svetlana
//   O'Donnell, Claire
//T
//   Tucker, Lance
//   Tucker, Michael
//Z
//   Zabokritski, Eugene
 
 

当您运行此查询时，就会看到组现在已按字母顺序排序。

使用 let 引入标识符

·        您可以使用 let 关键字为查询表达式中的任何表达式结果引入标识符。 此标识符可以提供方便（如下面的示例所示），也可以通过存储表达式的结果来避免多次计算，从而提高性能。

C#

 
// studentQuery5 is an IEnumerable<string>
// This query returns those students whose
// first test score was higher than their
// average score.
var studentQuery5 =
    from student in students
    let totalScore = student.Scores[0] + student.Scores[1] +
        student.Scores[2] + student.Scores[3]
    where totalScore / 4 < student.Scores[0]
    select student.Last + " " + student.First;
 
foreach (string s in studentQuery5)
{
    Console.WriteLine(s);
}
 
// Output:
// Omelchenko Svetlana
// O'Donnell Claire
// Mortensen Sven
// Garcia Cesar
// Fakhouri Fadi
// Feng Hanying
// Garcia Hugo
// Adams Terry
// Zabokritski Eugene
// Tucker Michael
 
 

有关更多信息，请参见let子句（C#参考）。

在查询表达式中使用方法语法

·        如LINQ中的查询语法和方法语法 (C#) 中所述，一些查询操作只能使用方法语法表示。 下面的代码计算源序列中每个 Student 的总分，然后对该查询的结果调用 Average() 方法来计算班级的平均分。 请注意，查询表达式的两边使用了括号。

C#

 
var studentQuery6 =
    from student in students
    let totalScore = student.Scores[0] + student.Scores[1] +
        student.Scores[2] + student.Scores[3]
    select totalScore;
 
double averageScore = studentQuery6.Average();
Console.WriteLine("Class average score = {0}", averageScore);
 
// Output:
// Class average score = 334.166666666667
 
 

在 select 子句中转换或投影

1.    查询生成的序列的元素与源序列中的元素不同，这种情况很常见。 删除或注释掉您之前的查询和执行循环，并用下面的代码替换它。 请注意，该查询返回一个字符串（而非 Students）序列，这种情况将反映在 foreach 循环中。

C#

 
IEnumerable<string> studentQuery7 =
    from student in students
    where student.Last == "Garcia"
    select student.First;
 
Console.WriteLine("The Garcias in the class are:");
foreach (string s in studentQuery7)
{
    Console.WriteLine(s);
}
 
// Output:
// The Garcias in the class are:
// Cesar
// Debra
// Hugo
 
 

2.    本演练前面的代码指出班级的平均分约为 334分。 若要生成总分高于班级平均分的 Students 及其 Student ID 的序列，可以在 select 语句中使用匿名类型：

C#

 
var studentQuery8 =
    from student in students
    let x = student.Scores[0] + student.Scores[1] +
        student.Scores[2] + student.Scores[3]
    where x > averageScore
    select new { id = student.ID, score = x };
 
foreach (var item in studentQuery8)
{
    Console.WriteLine("Student ID: {0}, Score: {1}", item.id, item.score);
}
 
// Output:
// Student ID: 113, Score: 338
// Student ID: 114, Score: 353
// Student ID: 116, Score: 369
// Student ID: 117, Score: 352
// Student ID: 118, Score: 343
// Student ID: 120, Score: 341
// Student ID: 122, Score: 368
 
 

后续步骤

熟悉了在 C# 中使用查询的基本情况后，便可以开始阅读您感兴趣的具体类型的 LINQ提供程序的文档和示例：

LINQ to SQL [LINQ to SQL]

LINQ to DataSet

LINQ to XML

LINQ to Objects

 

支持 LINQ 的 C# 功能

查询表达式

var query = from str in stringArray

           group str by str[0] into stringGroup

           orderby stringGroup.Key

           select stringGroup;

隐式类型化变量 (var)

var number = 5;

var name = "Virginia";

var query = from str in stringArray

           where str[0] == 'm'

           select str;

匿名类型

select new {name = cust.Name, phone =cust.Phone};

 

Lambda 表达式

Lambda 表达式是一种内联函数，该函数使用 => 运算符将输入参数与函数体分离，并且可以在编译时转换为委托或表达式树。 在LINQ 编程中，在您对标准查询运算符进行直接方法调用时，会遇到 lambda 表达式。



赫曦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Sharepoint 开发人员演练
05-17
练习 1 ― Web 部件和 Linq 演练 ............................................................................................................................. 4 任务 1 ― 创建新 SharePoint 项目 ...........
查询表达式(LINQ)简介
Kevin的专栏
09-24 3761
LINQ是Language Integrated Query的简称,LINQ定义了一组标准查询操作符允许查询作用于所有基于IEnumerable接口的源. LINQ包括五个部分：LINQ to Objects、LINQ to DataSets、LINQ to SQL、LINQ to Entities、LINQ to XML.   所有 LINQ 查询操作都由以下三个不同的操作组成：     
LINQ 函数的实战演练测试
dienen0325的博客
11-22 166
1、首先定义一个图书类。专门存放图书的属性信息。 代码如下： 1 //Book.cs 2 3 using System; 4 5 namespace LinqTest 6 { 7 public class Book 8 { 9 public string Name { get; set; } 1...
Linq集成化查询学习笔记
Clement
02-02 295
文章目录1 简介2 基本语法2.1 对查询结果类型的巧妙处理2.2 延迟执行与强制立即执行3 过滤操作3.1 筛选3.2 排序3.3 分组4 更复杂的查询4.1 动态创建类型4.2 联合查询5 嵌套查询 1 简介 LINQ（ Language-Integrated Query）可以按照字面意思直接翻译为“语言集成查询”。 它是整合到C#语言中的一种非常强大且实用的查询技术。使用LINQ可以轻松做到： 对如数组、集合等数据结构进行查询、筛选、排序等操作。 可以用于与数据库交互。LINQ表达式可以转化为SQL
解决重复出现问题的 (LINQ) 方法示例
寒冰屋的专栏
06-06 531
目录 介绍 问题 第一个解决方案 第二种解决方案 结论 介绍 大多数时候，我们从查询数据模型的角度考虑 LINQ。 然而，它可以为问题提供一组替代解决方案，我们只是以一种非常原始和基本的方式进行演练。那是因为它用于对任何数据类型的泛型执行操作。 问题 我最近处理的一项任务是找出一系列数字中的差距。让我们来讨论一下当一个人在第一阶段着手这项任务时想到的第一个解决方案。 第一个解决方案 为了能够跟上讨论，创建一个 .NET 控制台应用程序并将以下代码复制到program.cs类文件中：
linqToObjects演练
06-04
LINQ示例代码演练 LINQ示例代码演练
SharePoint_2010_开发人员演练.pdf
01-16
练习 1 ― Web 部件和 Linq 演练 ............................................................................................................................. 4 任务 1 ― 创建新 SharePoint 项目 ...........
航空订票系统java源码-CouchbaseTravel:CouchbaseTravel
06-06
和键值设置/获取操作）演练完整的 Web 应用程序，弥合了简单和高级 Couchbase 概念之间的差距。 本教程的完整源代码可在 GitHub 。 本教程使用 Couchbase Server 4.0 附带的travel-sample数据集。 生成 Web 应用程序...
c# 无法加载DLL找不到指定的模块。 (异常来自 HRESULT:0x8007007E)
conganguo的专栏
07-31 9909
刚刚遇到这个错误，dll是非托管代码xie的，
c#编写部署windows服务
conganguo的专栏
12-20 2574
什么是windows服务      Windows服务，微软的官方定义是这样的：Microsoft Windows 服务（即以前的 NT 服务）使您能够创建在它们自己的 Windows 会话中可长时间运行的可执行应用程序。这些服务可以在计算机启动时自动启动，可以暂停、禁用和重新启动而且不显示任何用户界面。 查找服务          Window开始-搜索栏输入“服务”-即可找到服务
LINQ(四)查询类型、查询语法与查询方法
conganguo的专栏
10-18 741
LINQ 查询操作中的类型关系 本章介绍了三种查询类型。 不转换源数据的查询 下图演示不对数据执行转换的 LINQ to Objects 查询操作。 源包含一个字符串序列，查询输出也是一个字符串序列。 1.    数据源的类型参数决定范围变量的类型。 2.    选择的对象的类型决定查询变量的类型。 此处的 name 为一个字符串。 因此，查询变量是一个IEnumerable字符
c#事件和委托的定义和使用
conganguo的专栏
10-06 635
委托和事件的使用例子
windows service初探
conganguo的专栏
03-28 618
详细项目创建过程，参照以下链接，在此就不具体copy文字了: http://www.cnblogs.com/sorex/archive/2012/05/16/2502001.html 根据上面链接中文章的步骤，vs新建一个windows service，在OnStart方法下写业务逻辑即可。右击设计器界面，点击“添加安装程序”按钮，按照文章中的步骤对Service属性进行命名。 本文
线程（二）Thread类
conganguo的专栏
10-20 581
使用thread类可以创建和控制线程，设置其优先级并获取状态。 1开启一个最简单的线程 首先声明一个thread实例，再启动线程，如下： usingSystem; usingSystem.Threading;   classTest {     static void Main()     {        Thread newThread =            
List自定义排序算法
conganguo的专栏
10-08 545
利用List.Sort(泛型 Comparison)，如下示例： using System; using System.Collections.Generic; public class Example {     private static int CompareDinosByLength(string x, string y)     {         if (x == nu
线程（一）概述
conganguo的专栏
10-19 520
线程是程序中独立的指令流
委托（一）C# 中委托的发展
conganguo的专栏
10-17 516
在 C# 1.0 中，您通过使用在代码中其他位置定义的方法显式初始化委托来创建委托的实例。 C# 2.0 引入了匿名方法的概念，作为一种编写可在委托调用中执行的未命名内联语句块的方式。 C# 3.0 引入了 Lambda 表达式，这种表达式与匿名方法的概念类似，但更具表现力并且更简练。 这两个功能统称为“匿名函数”。 通常，针对 .NET Framework 版本 3.5 及更高版本的应用程序
LINQ(二)基本 LINQ 查询操作
conganguo的专栏
10-18 508
获取数据源 在 LINQ 查询中，第一步是指定数据源。 像在大多数编程语言中一样，在 C# 中，必须先声明变量，才能使用它。 在 LINQ 查询中，最先使用 from 子句的目的是引入数据源 (customers) 和范围变量 (cust)。 C#   //queryAllCustomers is an IEnumerable var queryAllCustomers = fro
vbnet linq
最新发布
09-11
VB.NET 中的 LINQ 是一种强大的查询语言和操作集合的技术。LINQ (Language Integrated Query，语言集成查询) 提供了一种统一的方式来查询各种数据源，如集合、数据库、XML 等。 使用 LINQ，您可以使用类似 SQL 的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

赫曦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值