C# 中的 LinQ :从基础到最佳实践

最新推荐文章于 2024-08-10 08:16:32 发布

11小猪会飞11

最新推荐文章于 2024-08-10 08:16:32 发布

阅读量931

点赞数 5

文章标签： c# linq 开发语言

本文链接：https://blog.csdn.net/SS33SSS/article/details/136863419

版权

概述：LinQ C# 基础：成功的基石在我们踏上在 C# 中掌握 LinQ 的激动人心的旅程之前，了解 LinQ 的来源以及它如何适应 C# 语言环境至关重要。通过熟悉关键的 LinQ 概念和组件，我们正在为成功的学习和应用奠定基础。LinQ 在 C# 语言中的历史和出现#如果您更喜欢直接进入实践部分，并且本文看起来不像学校历史课，请转到下一节。LinQ 或语言集成查询是在 C# 3.0 中引入的，是对 Microsoft .NET Framework 的革命性补充。通过与 C# 语言功能无缝集成，它使开发人员能够针对各种数据源编写更简洁、更具表现力和更可靠的查询。在本节中，我们将深入探讨 LinQ

LinQ C# 基础：成功的基石

在我们踏上在 C# 中掌握 LinQ 的激动人心的旅程之前，了解 LinQ 的来源以及它如何适应 C# 语言环境至关重要。通过熟悉关键的 LinQ 概念和组件，我们正在为成功的学习和应用奠定基础。

LinQ 在 C# 语言中的历史和出现#

如果您更喜欢直接进入实践部分，并且本文看起来不像学校历史课，请转到下一节。

LinQ 或语言集成查询是在 C# 3.0 中引入的，是对 Microsoft .NET Framework 的革命性补充。通过与 C# 语言功能无缝集成，它使开发人员能够针对各种数据源编写更简洁、更具表现力和更可靠的查询。

在本节中，我们将深入探讨 LinQ 的起源、它的发展以及它如何影响后续的 C# 功能。我们还将探讨它对编程环境的影响，以及它为 C# 中的查询和数据操作带来的各种改进。

早期：需要统一的查询语言

在引入 LinQ 之前，在 C# 中查询和操作数据是一项艰巨且脱节的任务。开发人员必须应对多种查询语言和方法，例如用于数据库的 SQL、用于 XML 数据的 XPath 以及用于其他数据类型的自定义解决方案。

这些不同的方法缺乏与 C# 的集成，这阻碍了生产力，并导致代码过于复杂和容易出错。

认识到对统一查询语言的需求，C# 的创建者着手开发一个功能强大、灵活且集成的解决方案，以满足各种数据源的需求。他们设想了一种语言丰富、声明性和强类型的查询语言，该语言将利用 C# 的强大功能，并带来性能和可维护性优势。

LinQ 的诞生：C# 3.0 及其改变游戏规则的功能

2007 年 11 月，Microsoft 发布了 C# 3.0 和 .NET Framework 3.5，其中引入了多个突破性功能，包括扩展方法、匿名类型、lambda 表达式，以及最重要的 LinQ。这些创新对于使 LinQ 能够兑现其作为无缝、富有表现力和统一的查询框架的承诺至关重要。

通过利用这些功能，LinQ 使开发人员能够编写更简洁、更具表现力的代码，这些代码易于理解和维护。扩展方法的引入允许在各种数据源上创建类似枚举的查询，而 lambda 表达式和匿名类型使得以较少的详细程度定义和操作复杂的查询表达式成为可能。

请看这个经典示例，它演示了 LinQ 如何简化和改进 C# 中的查询。如果没有 LinQ，从集合中检索所有偶数将需要更复杂的循环，如下所示：foreach

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };  
List<int> evenNumbers = new List<int>();  
  
foreach (int number in numbers)  
{  
    if (number % 2 == 0)  
    {  
        evenNumbers.Add(number);  
    }  
}

但是使用 LinQ，可以使用更优雅、更简洁的查询表达式来实现相同的结果，如下所示：

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };  
  
IEnumerable<int> evenNumbers = from number in numbers  
                                where number % 2 == 0  
                                select number;

LinQ 的影响：彻底改变 C# 编程领域

LinQ 自成立以来，就对 C# 编程领域产生了深远而持久的影响。它改变了开发人员对查询的思考方式，将其从一系列繁琐的任务转变为编程语言中流畅而有凝聚力的部分。

此外，它还为激动人心的改进和增强打开了大门，例如异步查询、异步流式处理和 LINQ to Objects 提供程序中的并行性。

此外，LinQ 的出现促进了新库（如 Entity Framework）的开发，这些库通过丰富的数据访问和查询功能进一步扩展了 LinQ 的功能。

旅程仍在继续：发展和扩展 LinQ

自首次发布以来，LinQ 一直与 C# 和 .NET 平台一起不断发展壮大。例如，Microsoft的.NET Core计划确保了LinQ仍然是该平台未来的重要组成部分。

语言和库中经常添加新功能和改进，使 LinQ 功能更强大、适应性更强，并且对于现代开发来说是不可或缺的。

语言集成查询（LinQ）解释

LinQ 提供了一种统一的、富有表现力的语法，用于查询不同的数据类型，如内存中对象、XML 数据和关系数据库。凭借其易于阅读的性和编译时类型检查，LinQ 使处理数据变得方便和愉快。让我们仔细看看一些 LinQ 基础知识。

LinQ 命名空间和程序集

LinQ 在 .NET Framework 中的各种命名空间中都可用。您将与之交互的主要命名空间包括：

System.Linq：包含可枚举集合的基本 LinQ 扩展方法
System.Data.Linq：提供 LinQ-to-SQL 组件
System.Xml.Linq：包含 LinQ-to-XML 功能

要使用 LinQ，您只需通过在 C# 代码中添加指令来导入所需的命名空间，例如 .using System.Linq;

LinQ 中的表达式、委托和匿名方法

表达式、委托和匿名方法是支撑 LinQ 功能的基本组件。通过了解这些概念如何相互作用并相互支持，您可以在 C# 开发项目中充分利用 LinQ 的强大功能。为了提供更多上下文并更有效地说明它们的用法，让我们更深入地了解这些概念以及示例：

表达式

表达式是生成值的 C# 代码块。LinQ 查询通常涉及使用谓词表达式筛选或操作数据，谓词表达式是返回或 .由于其简洁和富有表现力的性质，lambda 表达式（在 C# 3.0 中引入）通常用于这些方案。truefalse

简单谓词表达式示例：

Func<int, bool> isEven = x => x % 2 == 0;

在此示例中，表达式是一个 lambda 表达式，它表示一个谓词，用于检查给定整数是否为偶数。x => x % 2 == 0

代表

委托是类型安全的函数指针，用于封装对方法的引用。它们对 LinQ 至关重要，因为它们提供了在查询中使用方法时所需的灵活性。

方法可以分配给委托，而委托又可以用作其他方法的参数，从而有效地提供了一种“插入”功能的方法。

这允许 LinQ 查询利用自定义方法进行操作，例如根据不同的条件进行筛选、排序或分组。

请考虑以下利用委托进行筛选的 LINQ 查询：

public delegate bool IsEvenDelegate(int number);  
  
public static bool IsEven(int number)  
{  
    return number % 2 == 0;  
}  
IsEvenDelegate isEvenDel = IsEven;  
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };  
IEnumerable<int> evenNumbers = numbers.Where(n => isEvenDel(n));

在此示例中，我们创建了一个自定义委托和一个检查数字是否为偶数的方法。然后，我们将该方法分配给委托，并在我们的子句中使用它从列表中过滤掉偶数。IsEvenDelegateIsEven()Where

匿名方法

匿名方法（在现代 C# 中主要表示为 lambda 表达式）为定义内联函数提供了更简洁、更具表现力的语法。这些函数称为“匿名”，因为它们不需要显式方法名称。

这种简洁性在编写 LinQ 查询时尤为重要，因为它可以显著降低详细程度并增强代码的可读性。

请考虑以下示例，该示例演示了如何通过 LinQ 中的 lambda 表达式使用匿名方法：

List<string> names = new List<string> { "Alice", "Bob", "Carol", "David" };  
  
IEnumerable<string> namesStartingWithC = names.Where(name => name.StartsWith("C"));

在这里，我们使用 lambda 表达式作为匿名方法来过滤名称列表，仅保留以字母“C”开头的名称。与使用单独的命名方法相比，使用 lambda 表达式使查询更直观、更易于阅读。name => name.StartsWith("C")

强势起步：用 C 语言编写您的第一个 LinQ 查询#

是时候开始制作 LinQ 查询了！在本节中，我们将分解查询语法、结构以及如何筛选和转换数据等基础知识，以便您为首次涉足 LinQ 做好准备。

基本 LinQ 查询语法和结构

在 LinQ 中，查询以 clause 开头，该子句指定您正在使用的数据源，并引入查询变量作为范围变量。之后，您可以链接查询运算符（如、、和）来定义筛选器、转换和其他操作。查看此示例以了解语法：fromwhereselectgrouporder

// Query syntax example  
var results = from student in students  
              where student.Age > 18  
              orderby student.Name ascending  
              select student.Name;

C# 和 LinQ 中的隐式类型局部变量（var）

与 LinQ 完美配合的一个漂亮的 C# 功能是 var 关键字，它允许隐式类型的局部变量。为什么这很重要？打字简单！

var 关键字允许编译器推断结果类型，因此您可以专注于构建查询，而不必担心微调返回类型。

// Using var with LinQ  
var studentsWithHighScores = from student in students  
                              where student.Score > 80  
                              select student;

From、Select 和 Where 关键字用法

让我们更深入地研究、和关键字。简而言之，以下是他们所做的：fromselectwhere

From：定义数据源并引入范围变量（例如，from student in students)
选择：指定要从数据源中提取的数据（例如，select student.Name)
其中：根据条件（例如，where student.Age > 18)

研究下面的例子，我们检索按升序排序的学生姓名：

// Using from, select, and where  
var names = from student in students  
            where student.Age > 18  
            orderby student.Name ascending  
            select student.Name;

现在让我们考虑一个场景，我们只想检索女学生的名字。注意子句的变化：where

// Using from, select, and where with a different condition  
var femaleNames = from student in students  
                  where student.Gender == "Female"  
                  orderby student.Name ascending  
                  select student.Name;

筛选、投影和转换操作

您可能会想，“如何对我的数据应用各种操作？好吧，有了 LinQ，可能性几乎是无穷无尽的。以下是一些需要考虑的常见操作：

筛选：用于应用缩小结果集范围的条件where
投影：用于将数据源转换为新的格式或结构select
**转换：**利用、、、联接和 set 运算符对数据源进行更高级的重塑grouporderby

例如，如果要获取分数高于 80 分的学生姓名，按年龄排序：

var highScoreNames = from student in students  
                     where student.Score > 80  
                     orderby student.Age  
                     select student.Name;

假设现在您想按班级对学生进行分组：

var studentsByClass = from student in students  
                      group student by student.Class into studentGroup  
                      select new { Class = studentGroup.Key, Students = studentGroup };

在此示例中，我们使用关键字根据数据源的属性对数据源进行分组。然后，我们用将结果投影到一个新的匿名类型中，其中包含该类和属于该类的学生的集合。groupstudentsClassselect

请注意，转换如何扩展了 LinQ 的功能，使我们能够更有效地重组数据。

高级 LinQ 查询技术和策略

现在您已经掌握了基础知识，是时候处理更复杂的查询技术了！在本节中，我们将探讨排序、分组和聚合操作，以及如何构造动态查询以实现最大的灵活性。

排序和分组：组织数据

数据组织对于清晰和理解至关重要。在 LinQ 中，并提供强大的方法来对数据进行排序和分类。orderbygroupby

该关键字允许您根据指定字段按升序或降序对数据进行排序：orderby

// Ordering data  
var orderedStudents = from student in students  
                      orderby student.Name  
                      select student;

要按分数降序对学生进行排序，请修改子句，如下所示：orderby

// Ordering data by score descending  
var orderedStudentsByScore = from student in students  
                             orderby student.Score descending  
                             select student;

groupby另一方面，根据共享特征整合数据：

// Grouping data by age  
var studentsGroupedByAge = from student in students  
                           group student by student.Age into groupedStudents  
                           select groupedStudents

聚合运算（总和、计数、最小值、最大值、平均值）

LinQ C# 还为聚合操作提供了可靠的支持，例如计算总和、计数、最小值和最大值以及平均值

// Aggregation operations example  
var maxScore = students.Max(student => student.Score);  
var minScore = students.Min(student => student.Score);  
var averageScore = students.Average(student => student.Score);  
var totalScoreSum = students.Sum(student => student.Score);  
var studentCount = students.Count(student => student.Age > 18);

让我们演示如何获得分数高于 90 的学生计数：

// Counting the number of students with scores above 90  
var highScoreCount = students.Count(student => student.Score > 90);

集合操作（Distinct、Union、Intersect、Except）

管理集合？不用担心！LinQ 为您提供了各种集合操作，包括：

Distinct()：删除重复值
Union()：合并两个序列，没有重复
Intersect()：从两个序列中检索公共元素
Except()：从第一个序列中获取元素，而不是在第二个序列中获取元素

下面是使用、和的示例：Distinct()Union()Intersect()

// Set operations example  
var firstNames = new string[] { "John", "Jane", "Jim", "Jane" };  
var lastNames = new string[] { "Doe", "Smith", "Adams", "John" };  
  
var distinctFirstNames = firstNames.Distinct(); // "John", "Jane", "Jim"  
var unionNames = firstNames.Union(lastNames); // "John", "Jane", "Jim", "Doe", "Smith", "Adams"  
var intersectNames = firstNames.Intersect(lastNames); // "John"

动态查询生成和执行

LinQ 的一个惊人特性是它支持动态查询生成和执行。这为基于用户输入或应用程序状态构造自定义查询提供了难以置信的灵活性。例如，想象一下基于用户界面中的复选框构建搜索过滤器：

// Dynamic query generation  
IEnumerable<Student> filteredStudents = students;  
  
if (someCondition)  
{  
    filteredStudents = filteredStudents.Where(student => student.Age > 18);  
}  
if (anotherCondition)  
{  
    filteredStudents = filteredStudents.OrderBy(student => student.Name);  
}  
var results = filteredStudents.ToList();

在此示例中，我们根据和的值动态构建 LinQ 查询。这使我们能够使查询适应不同的方案或用户选择，这在处理复杂的过滤器或不同的应用程序要求时特别有用。someConditionanotherCondition

深入研究 LinQ 查询运算符

现在我们已经介绍了基础知识，甚至探索了一些更高级的技术，让我们更深入地了解 C# 开发人员可以使用的各种 LinQ 查询运算符！

标准查询运算符概述

标准查询运算符构成了您将使用 LinQ 执行的许多操作的基础。这些运算符可应用于实现接口的集合，并分为多个类别，例如：IEnumerable<T>

过滤（，WhereOfType)
投影（，SelectSelectMany)
分区（，SkipTake)
订购（，，OrderByThenByReverse)
分组（，GroupByToLookup)
设置操作（前面提到）
转换（，，，ToArrayToDictionaryOfTypeCast)
元素（，，，FirstLastSingleElementAt)
聚合（前面也提到过）

每个运算符在构建 LinQ 查询中都起着至关重要的作用，因此不要忘记混合、匹配和定制组合以满足您的特定数据需求！

让我们更深入地了解其中的一些运算符。

元素和生成运算符

元素运算符从数据源中检索特定元素，例如按索引访问数组元素。典型的元素运算符包括、、和。例如，看看我们如何获得第一个分数大于 80 的学生：FirstFirstOrDefaultLastLastOrDefaultSingleSingleOrDefaultElementAt

// Element operator example  
var firstHighScorer = students.First(student => student.Score > 80);

现在，看一个使用运算符访问列表中的第五个学生的示例：ElementAt

// Element operator example - ElementAt  
var fifthStudent = students.ElementAt(4); // Zero-based index

生成运算符（如、和）创建具有特定特征的集合的新实例。当您需要以编程方式生成集合时，它们会派上用场。下面是一个使用和的示例：RangeRepeatEmptyRangeRepeat

// Generation operator example - Range  
var numbers = Enumerable.Range(1, 10);  // Generates numbers 1 to 10  
  
// Generation operator example - Repeat  
var repeatedValue = Enumerable.Repeat("Hello", 5); // Creates an IEnumerable with 5 "Hello" values

LinQ 查询中的分区和分页

分区是一种强大的技术，可以从较大的集合中提取较小的数据子集，并且对于分页特别有用。一些键分区运算符包括、、及其组合：SkipTake

Take(n)：检索第一个元素n
Skip(n)：跳过第一个元素并返回其余元素n
TakeWhile(condition)：在特定条件成立时取元素
SkipWhile(condition)：在条件为 true 时跳过元素并返回其余元素

请看这个示例，演示使用和进行分页：SkipTake

// Pagination example  
int pageNumber = 1;  
int pageSize = 5;  
  
var page = students  
    .Skip((pageNumber - 1) \* pageSize)  
    .Take(pageSize);

要检索学生的第二页，只需更改值：pageNumber

// Pagination example - second page  
pageNumber = 2;  
  
var secondPage = students  
    .Skip((pageNumber - 1) * pageSize)  
    .Take(pageSize);

转换运算符：就地查询转换

转换运算符将查询结果转换为其他格式，例如数组、字典或更改元素类型。一些常用的转换运算符是、、、和。下面是一个示例，演示如何将 LinQ 查询结果转换为字典：ToArrayToListToDictionaryOfTypeCast

// Conversion operator example  
var studentDictionary = students  
    .Where(student => student.Age > 18)  
    .ToDictionary(student => student.Id, student => student.Name);

现在，如果我们想将结果转换为数组，只需使用运算符：ToArray

// Conversion operator example - ToArray  
var adultStudentsArray = students  
    .Where(student => student.Age > 18)  
    .ToArray();

通过这些转换运算符，可以轻松处理所需格式的输出，从而确保与应用程序中的各种数据处理任务更好地兼容。

利用 LinQ 的 Lambda 表达式和扩展方法的强大功能

当您将 Lambda 表达式和扩展方法与 LinQ 结合使用时，就像将 nitro 添加到您的开发引擎中一样。在本节中，我们将探讨这些概念如何增强 LinQ 查询。

Lambda 表达式：简洁而富有表现力的语法

Lambda 表达式是一种简洁、富有表现力的语法，用于动态创建匿名函数。它们是 LinQ 如此强大的核心。

使用 lambda 运算符定义 lambda 表达式。=>

以下示例检索了所有分数高于 80 的学生：

// Lambda expression example  
var highScorers = students.Where(student => student.Score > 80);

您可以将多个 lambda 表达式链接在一起，以实现复杂的查询逻辑。请注意，在下面的示例中，我们如何组合两个单独的表达式：

// Chaining lambda expressions  
var olderHighScorers = students  
    .Where(student => student.Score > 80)  
    .Where(student => student.Age >= 18);

使用扩展方法增强 LinQ

扩展方法提供了一种优雅的方式来扩展现有类型的功能，而无需显式修改其源代码。当与 LinQ 查询结合使用时，这使得语法具有高度的表现力和可读性。

您已经在命名空间中找到许多扩展接口功能的扩展方法。为了进一步增强查询功能，您甚至可以创建自定义扩展方法。System.LinqIEnumerable<T>

// Custom extension method example  
public static class StringExtensions  
{  
    public static bool ContainsCaseInsensitive(this string source, string value)  
    {  
        return source.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0;  
    }  
}  
  
// Using custom extension method in LinQ query  
var caseInsensitiveSearch = students  
    .Where(student => student.Name.ContainsCaseInsensitive("john"));

专用功能的自定义扩展方法

也许您遇到了标准 LinQ 查询运算符无法满足的专用查询需求。不要害怕！您可以开发适合您特定要求的自定义扩展方法。请考虑一个场景，其中你希望根据自定义评分公式为学生实现自己的筛选方法：

public static class CustomFilters  
{  
    public static IEnumerable\<Student> WithCustomScore(this IEnumerable\<Student> students, int threshold)  
    {  
        return students.Where(student => CustomScoringFormula(student) > threshold);  
    }  
  
  
private static int CustomScoringFormula(Student student)  
    {  
        // Compute custom score based on student properties  
        return 0; // Example placeholder  
    }  
}  
// Using custom extension method in LinQ query  
var studentsWithCustomScore = students.WithCustomScore(90);

在自定义扩展方法方面，天空是无限的，因此请拥抱您的创造力并利用它们来满足您的特定发展需求。

提升 LinQ 技能：连接到各种数据源

LinQ 专为多功能性而构建 - 您可以使用的数据源越多样化，您的查询功能就越强大。本节深入探讨如何将 LinQ 与各种数据源集成，使你具备处理复杂的实际场景所需的技能。

LinQ 提供程序简介

LinQ 提供程序充当 LinQ 查询和不同类型的数据源之间的桥梁，将 LinQ 查询转换为指定数据源的适当格式。一些常用的 LinQ 提供程序包括：

System.Data.Linq对于 LinQ to SQL
System.Data.Entity对于实体框架
System.Xml.Linq对于 LinQ 到 XML

通过利用适当的 LinQ 提供程序，您可以跨不同的数据源编写一致的 LinQ 查询。让我们仔细看看这些 LinQ 提供程序以及示例实现。

LinQ to SQL 和 Entity Framework 集成

在关系数据库领域，LinQ to SQL 和 Entity Framework 是主要的数据访问技术。两者都允许您通过将 LinQ 查询转换为 SQL 命令来直接从 C# 代码使用数据库。

LinQ to SQL 将 C# 类映射到数据库表，使您能够使用 LinQ 查询查询、插入、更新和删除记录。Entity Framework 通过添加一个完整的、功能丰富的 ORM（对象关系映射器）将其提升了一个档次。

下面是使用 LinQ to SQL 查询数据库的示例：

// LinQ to SQL example  
DataContext context = new DataContext("<connection-string>");  
Table<Student> studentTable = context.GetTable<Student>();  
  
var result = from student in studentTable  
             where student.Age > 18  
             select student;

若要使用 LinQ to SQL 更新记录，请按照以下示例操作：

// LinQ to SQL update example  
var studentToUpdate = studentTable.Single(student => student.Id == someId);  
studentToUpdate.Name = "NewName";  
context.SubmitChanges();

下面是一个使用 Entity Framework 的示例：And here's an example using Entity Framework：

// LinQ to Entity Framework example  
using (var context = new SchoolContext())  
{  
    var result = from student in context.Students  
                 where student.Age > 18  
                 select student;  
}

若要使用实体框架执行更新操作，请考虑以下示例：

// LinQ to Entity Framework update example  
using (var context = new SchoolContext())  
{  
    var studentToUpdate = context.Students.Single(student => student.Id == someId);  
    studentToUpdate.Name = "NewName";  
    context.SaveChanges();  
}

释放 LinQ 到 XML 的潜力

使用 XML 不再是一件苦差事，这要归功于 LinQ to XML。通过使用命名空间提供的一组特定于 XML 的查询运算符，可以毫不费力地查询和操作 C# 中的 XML 文档。System.Xml.Linq

看一下这个示例，它演示了如何使用 LinQ 查询 XML 文档：

// LinQ to XML example  
XDocument xdoc = XDocument.Load("\<path-to-xml-file>");  
  
var results = from element in xdoc.Descendants("Student")  
              where (int)element.Element("Age") > 18  
              select element;

除了查询之外，还可以使用 LinQ to XML 来操作 XML 结构，例如添加新元素：

// LinQ to XML - Adding a new element  
XElement newStudent = new XElement("Student",  
    new XElement("Name", "New Student"),  
    new XElement("Age", 20)  
);  
  
xdoc.Root.Add(newStudent);  
xdoc.Save("<path-to-modified-xml-file>");

掌握 LinQ 到 JSON 的动态数据处理

现代应用程序通常需要处理 JSON 数据，而 Newtonsoft.Json（也称为 Json.NET）库是在 C# 中处理 JSON 的热门选择。随着 Json.NET 中 JObjects 和 JArrays 的引入，将 LinQ 合并到 JSON 中变得轻而易举。

下面是使用 LinQ 和 Json.NET 筛选 JSON 数据的示例：

// Newtonsoft Json with LinQ  
using Newtonsoft.Json.Linq;  
  
string json = "...";  
JArray jsonArray = JArray.Parse(json);  
var filteredData = jsonArray  
 .Where(obj => (int)obj["Age"] > 18)  
 .Select(obj => obj["Name"]);

您还可以使用 LinQ 通过 Json.NET 修改 JSON 数据：

// Modify JSON data using LinQ and Json.NET  
JObject jsonObj = JObject.Parse(json);  
jsonObj["Students"][0]["Name"] = "Updated Name";

利基数据源的自定义 LinQ 提供程序

有时，您可能需要创建自定义 LinQ 提供程序来查询缺乏现成支持的利基数据源。若要开发自定义提供程序，需要了解并实现 and 接口。IQueryProviderIQueryable<T>

虽然制作自定义 LinQ 提供程序需要深厚的专业知识，并且可能非常具有挑战性，但最好认识到存在满足独特数据访问方案的潜力。

例如，您可以创建一个自定义 LinQ 提供程序，用于查询内存中缓存、NoSQL 数据库或远程 API。一旦您掌握了 LinQ 提供程序开发的基础知识，可能性是无穷无尽的！

LinQ C 中的异步和并行查询执行#

优化性能和响应能力是现代应用程序的关键，而这正是异步和并行查询执行可以产生巨大影响的地方。在本节中，我们将探讨如何使用 async/await 和 PLINQ 增强 LinQ C#，优化代码执行以充分利用可用资源并缩短响应时间。

使用 async/await 的异步 LinQ 查询

从 .NET Framework 4.5 和 C# 5.0 开始，可以利用 async/await 来执行异步 LinQ 查询。可以使用、、等方法将任何实体框架查询转换为异步查询。ToListAsyncFirstOrDefaultAsyncAnyAsync

下面是将异步查询与实体框架结合使用的示例：Here's an example using an async query with Entity Framework：

// Async query with Entity Framework  
using (var context = new SchoolContext())  
{  
    var result = await context.Students  
        .Where(student => student.Age > 18)  
        .ToListAsync(); // Asynchronous execution  
}

请记住，并非所有 LinQ 提供程序都支持开箱即用的异步查询，但诸如此类的策略也有助于异步执行查询：Task.Run

// Making a non-async query asynchronous with Task.Run  
var result = await Task.Run(() => students.Where(student => student.Age > 18).ToList());

让我们看一下使用 HttpClient 的外部数据源上的异步查询示例：

// Async query on an external data source  
public async Task<IEnumerable<Student>> GetStudentsAsync()  
{  
    using (var httpClient = new HttpClient())  
    {  
        var json = await httpClient.GetStringAsync("https://api.example.com/students");  
        var jsonData = JArray.Parse(json);  
  
var students = jsonData  
            .Select(obj => new Student  
            {  
                Id = (int)obj["Id"],  
                Name = (string)obj["Name"],  
                Age = (int)obj["Age"]  
            });  
        return students;  
    }  
}

并行 LinQ （PLINQ）实现最佳性能

若要提高 LinQ 查询的性能，请考虑使用并行 LinQ （PLINQ），它可以将查询分布在多个 CPU 内核上，以更快地处理数据。PLINQ 建立在任务并行库（TPL）之上，为 LINQ-to-Objects 操作提供了出色的优化。将查询转换为并行查询很简单 — 只需在查询之前添加，如以下示例所示：.AsParallel()

// Parallel LinQ (PLINQ) example  
var sortedNames = students.AsParallel()  
    .Where(student => student.Age > 18)  
    .OrderBy(s => s.Name)  
    .Select(s => s.Name);

但是，使用 PLINQ 时要小心，因为某些操作可能会消耗更多资源或导致意外结果。在实施 PLINQ 之前和之后优先测量和评估查询的性能，以确保最佳用例。

在某些情况下，使用扩展方法可以帮助保持元素的顺序，尤其是在需要它的情况下。.AsOrdered()

// Parallel LinQ (PLINQ) with order preservation  
var sortedNames = students.AsParallel().AsOrdered()  
    .Where(student => student.Age > 18)  
    .OrderBy(s => s.Name)  
    .Select(s => s.Name);

LinQ 查询的线程处理和基于任务的注意事项

虽然异步和 PLINQ 查询在某些情况下可以显著提高性能，但您应该意识到多线程环境中可能会带来额外的复杂性和问题。确保仔细管理共享数据，利用同步机制，并正确处理异步或并行上下文中的异常。

最佳做法是，为从这些方法中获益匪浅的查询保留异步和 PLINQ，例如资源密集型计算、后台处理或响应时间较长的数据源。

始终在提高性能的优势与多线程执行带来的复杂性和潜在陷阱之间取得平衡。例如，请考虑以下示例，其中使用了共享数据结构：

var students = new List<Student>()  
{  
    new Student { Id = 1, Name = "John", Age = 20 },  
    new Student { Id = 2, Name = "Alice", Age = 19 },  
    new Student { Id = 3, Name = "Bob", Age = 21 }  
};  
  
var studentsList = new List<Student>();  
students.AsParallel().ForAll(student =>  
{  
    lock (studentsList) // We need to lock the shared data to prevent race conditions  
    {  
        studentsList.Add(student);  
    }  
});

在上面的示例中，我们通过使用锁在添加元素时同步对共享对象的访问来处理潜在的线程问题。这样可以防止由于并发访问数据结构而可能发生的任何争用条件。studentsList

LinQ C 的实际应用和案例研究#

为了完善您的 LinQ 专业知识，我们将探讨 LinQ C# 的各种实际应用和案例研究。您积累的实践经验越多，您就越有能力在自己的开发项目中有效地利用 LinQ。

在复杂的 C# 项目中实现 LinQ

LinQ 是复杂的大型 C# 项目中不可或缺的工具。例如，企业应用程序可能依赖于功能丰富的 ORM 框架，如 Entity Framework。

在这种情况下，LinQ 可以提供令人信服的生产力和性能组合，使您能够高效、富有表现力地执行复杂的查询和数据操作任务。

// Example: Using LinQ with Entity Framework  
using (var context = new SchoolContext())  
{  
    var studentsInMath = context.Students  
        .Where(student => student.Courses  
            .Any(course => course.Name == "Math"))  
        .ToList();  
}

此外，现代软件解决方案通常依赖于微服务架构，这可能涉及交换和处理来自众多互连服务的信息。LinQ 支持更轻松的数据解析、筛选和转换，从而提供更简化的开发体验。

LinQ 在 Web 开发中的应用：ASP.NET 和 MVC 应用程序

使用 ASP.NET 和 ASP.NET Core 进行 Web 开发可以从 LinQ 集成中获益匪浅。例如，在 MVC 应用程序中，您可以使用 LinQ 查询数据库并在视图中显示结果。这种技术组合有助于为用户创建无缝的、数据驱动的 Web 体验。

// Example: Using LinQ in an ASP.NET Core MVC application  
public async Task<IActionResult> Index()  
{  
    using (var context = new SchoolContext())  
    {  
        var students = await context.Students  
            .Where(student => student.Age >= 18)  
            .OrderBy(student => student.LastName)  
            .ToListAsync();  
  
return View(students);  
    }

请考虑一个示例，其中 Web 应用程序显示数据库中的学生及其相应班级的列表。使用 ASP.NET、Entity Framework 和 LinQ，可以根据需要查询、筛选和排序此信息，然后再将其显示给用户。

使用 Xamarin 和 LinQ 进行移动应用程序开发

在 LinQ 支持方面，移动应用程序开发也不甘落后。Xamarin 是一个跨平台的移动应用开发框架，它与 C# 和 LinQ 顺利集成，用于处理跨 Android、iOS 和通用 Windows 平台应用程序的数据访问和操作。

// Example: Using LinQ in a Xamarin.Forms application  
using (var dbContext = new AppDbContext())  
{  
    var students = dbContext.Students  
        .Where(student => student.Age >= 18)  
        .OrderBy(student => student.LastName)  
        .ToList();  
  
studentsListView.ItemsSource = students;  
}

即使支持脱机方案（例如在用户设备上存储和更新数据以便以后与后端数据源同步），使用 Xamarin、Entity Framework Core 和 LinQ 查询和更新本地数据库也会变得更加简单。

使用 LinQ C 为数据分析和机器学习提供支持#

人们经常将数据分析和机器学习与 Python 和 R 等语言联系在一起，但在 LinQ 的强大功能的帮助下，C# 也可以在这些领域发挥关键作用。

使用 ML.NET 时 - Microsoft 的 .NET 开源机器学习框架 - LinQ 在清理、转换和预处理机器学习模型的大量数据等任务中大放异彩。

// Example: Using LinQ for data preprocessing in ML.NET  
var data = new List<DataPoint>  
{  
    new DataPoint { Value1 = 1, Value2 = 2 },  
    new DataPoint { Value1 = 2, Value2 = 3 },  
    new DataPoint { Value1 = 3, Value2 = 4 },  
};  
  
var preprocessedData = data  
    .Select(dataPoint => new DataPoint  
    {  
        Value1 = dataPoint.Value1 * 10,  
        Value2 = dataPoint.Value2 * 10  
    })  
    .ToList();  
var context = new MLContext();  
var pipeline = context.Transforms.CustomMapping(input => preprocessedData, "DataPoints");

使用 LinQ C# 查询确保质量、性能和安全性

质量、性能和安全性对于任何软件开发工作都至关重要。本节提供有关调试、优化和确保 LinQ 查询安全性的见解，同时保持一流的代码质量。

LinQ 查询的调试技巧和技巧

与传统的调试技术相比，调试 LinQ 查询有时可能需要不同的方法。下面是一些提示和示例，可帮助您识别和解决 LinQ 代码的问题：

通过将查询分解为更小的部分，利用 Visual Studio 调试器功能（如监视窗口和数据提示）

var students = new List<Student>  
{  
    new Student { Id = 1, Name = "John", Age = 20 },  
    new Student { Id = 2, Name = "Alice", Age = 19 }  
};  
  
var query = students.Where(student => student.Age > 18);  
int count = query.Count(); // Set a breakpoint here to inspect query results

单独的查询定义和执行：这使您可以查明导致问题的确切步骤

var query = students.Where(student => student.Age > 18);  
var results = query.ToList(); // Set breakpoints to debug query definition and execution separately

将查询包装在一个块中，以便在调试期间检查异常详细信息try-catch

try  
{  
    var results = students.Where(student => student.Age > 18).ToList();  
}  
catch (Exception ex)  
{  
    // Examine exception details  
}

请考虑使用 OzCode 等插件扩展 Visual Studio，以增强 LinQ 调试功能

优化 LinQ 查询的性能

良好的性能是高质量软件的关键属性。通过遵循以下最佳实践来确保出色的 LinQ 查询性能：

使用分析工具（如 LINQPad、Entity Framework Profiler）或内置的 Visual Studio 工具分析查询的性能
通过使用预先加载、投影、筛选和分页等技术，最大限度地减少到数据源的往返次数并减少数据传输开销

using (var context = new SchoolContext())  
{  
    // Eager loading with Include, projection with Select, and paging with Skip/Take  
    var students = context.Students  
        .Include(student => student.Courses)  
        .Select(student => new { student.Name, student.Age })  
        .Where(student => student.Age > 18)  
        .OrderBy(student => student.Name)  
        .Skip(10)  
        .Take(20)  
        .ToList();  
}

考虑采用缓存策略来减少冗余数据访问和处理
在适当的情况下使用异步查询和 PLINQ 来优化资源密集型或 I/O 密集型方案中的性能（请参阅 ASD 部分中的前面示例）

LinQ C# 代码的单元测试和集成测试

编写可测试的代码并实现可靠的单元和集成测试对于确保 LinQ 查询的质量和可靠性至关重要。请记住以下测试策略：

通过隔离业务逻辑和数据访问代码，将 LinQ 查询设计为模块化和可测试的
使用 Moq 或 NSubstitute 等库对依赖数据源实施模拟测试

[Fact]  
public void Test_GetStudents_AgeAbove18()  
{  
    // Arrange  
    var students = ... // List of students  
    var repoMock = new Mock<IStudentRepository>();  
    repoMock.Setup(repo => repo.GetAll()).Returns(students);  
    var studentService = new StudentService(repoMock.Object);  
  
// Act  
    var result = studentService.GetStudentsAboveAge(18);  
    // Assert  
    Assert.NotNull(result);  
    ...  
}

利用 MSTest、xUnit 或 NUnit 等测试框架为查询创建一套全面的单元测试和集成测试
请考虑采用测试驱动的开发方法，即在实现之前编写测试，以帮助确保 LinQ 查询的正确性和可测试性

LinQ 查询开发中的安全最佳实践

作为负责任的 C# 开发人员，在处理数据操作和访问时，应始终优先考虑安全性。要降低 LinQ 查询中的安全风险，请执行以下操作：

应用适当的输入验证和卫生措施，以防止注射攻击
避免使用投影在查询结果中公开敏感数据

public IEnumerable<string> GetUserNames()  
{  
    using (var context = new DbContext())  
    {  
        return context.Users  
            .Select(user => user.UserName) // Project only necessary data to prevent exposing sensitive information  
            .ToList();  
    }  
}

对数据源实施适当的授权和访问控制
使用参数化查询：对于实体框架，在使用用户提供的输入时，请始终使用参数化查询

using (var context = new DbContext())  
{  
    // Parameterized query example with Entity Framework  
    var results = context.Users  
        .Where(user => user.Email == emailAddress)  
        .ToList();  
}

加载外部库或编写自定义查询提供程序时，请验证其可信度和安全做法

11小猪会飞11

关注

5
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
C# 中的 LinQ :从基础到最佳实践

标准查询运算符构成了您将使用 LinQ 执行的许多操作的基础。这些运算符可应用于实现接口的集合，并分为多个类别，例如：IEnumerable<T>过滤（，WhereOfType)投影（，SelectSelectMany)分区（，SkipTake)订购（，，OrderByThenByReverse)分组（，GroupByToLookup)设置操作（前面提到）转换（，，，ToArrayToDictionaryOfTypeCast)
复制链接

扫一扫