C#的LINQ查询是什么？如何使用？-C#.Net教程-PHP中文网

LINQ查询有两种主要语法模式：查询语法和方法语法。查询语法类似SQL，以from开头，适合复杂联接和分组，可读性强；方法语法基于扩展方法，通过链式调用实现，更灵活且支持更多操作符。两者功能等价，可根据场景混合使用。

c#的linq查询是什么？如何使用？

C#的LINQ查询，简单来说，就是一种让你可以用统一、声明式的方式来查询各种数据源的语言集成技术。它把查询操作直接融入到C#语言本身，不再需要你写一堆字符串拼接的SQL语句或者遍历集合的

foreach

登录后复制

循环。它的核心目的就是简化数据查询，让代码更易读、更安全。

解决方案

LINQ（Language Integrated Query）的出现，彻底改变了C#中处理数据的方式。以前，我们要么对着数据库写SQL，要么对着内存中的集合写一堆循环和条件判断。这两种方式，语法差异大，写起来也比较繁琐。LINQ的厉害之处在于，它提供了一套统一的查询语法和API，无论是操作内存中的对象集合（LINQ to Objects）、XML文档（LINQ to XML）、关系型数据库（LINQ to SQL/Entity Framework），甚至是其他数据源，你都可以用几乎一样的C#代码去查询和操作。

它的工作原理是，将你的C#查询表达式转换成对应数据源能够理解的指令。比如，对于数据库，它会生成相应的SQL语句；对于内存集合，它会执行高效的迭代和筛选。这不仅提高了开发效率，也大大增强了代码的可读性和可维护性。

要使用LINQ，你通常会引入

System.Linq

登录后复制

命名空间。最基本的用法，就是从一个数据源（比如一个

List<T>

登录后复制

或一个数据库上下文）开始，然后链式调用各种LINQ方法来筛选、排序、分组或投影数据。

using System;
using System.Collections.Generic;
using System.Linq;

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int CategoryId { get; set; }
}

public class Category
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class LinqDemo
{
    public static void Main(string[] args)
    {
        List<Product> products = new List<Product>
        {
            new Product { Id = 1, Name = "Laptop", Price = 1200.00m, CategoryId = 1 },
            new Product { Id = 2, Name = "Mouse", Price = 25.00m, CategoryId = 2 },
            new Product { Id = 3, Name = "Keyboard", Price = 75.00m, CategoryId = 2 },
            new Product { Id = 4, Name = "Monitor", Price = 300.00m, CategoryId = 1 },
            new Product { Id = 5, Name = "Webcam", Price = 50.00m, CategoryId = 3 },
            new Product { Id = 6, Name = "Headphones", Price = 150.00m, CategoryId = 3 }
        };

        List<Category> categories = new List<Category>
        {
            new Category { Id = 1, Name = "Electronics" },
            new Category { Id = 2, Name = "Peripherals" },
            new Category { Id = 3, Name = "Accessories" }
        };

        // 查找所有价格超过100的产品
        var expensiveProducts = products.Where(p => p.Price > 100);
        Console.WriteLine("价格超过100的产品:");
        foreach (var p in expensiveProducts)
        {
            Console.WriteLine($"- {p.Name} ({p.Price:C})");
        }

        Console.WriteLine("\n--------------------\n");

        // 按类别分组，并计算每个类别的产品数量
        var productsByCategory = products.GroupBy(p => p.CategoryId)
                                         .Select(g => new { CategoryId = g.Key, Count = g.Count() });

        Console.WriteLine("按类别分组的产品数量:");
        foreach (var item in productsByCategory)
        {
            var categoryName = categories.FirstOrDefault(c => c.Id == item.CategoryId)?.Name ?? "未知";
            Console.WriteLine($"- 类别: {categoryName}, 数量: {item.Count}");
        }

        Console.WriteLine("\n--------------------\n");

        // 联接产品和类别，显示产品名称和类别名称
        var productDetails = from p in products
                             join c in categories on p.CategoryId equals c.Id
                             where p.Price < 500 // 筛选条件也可以在这里
                             orderby p.Price descending // 排序
                             select new { p.Name, CategoryName = c.Name, p.Price };

        Console.WriteLine("价格低于500的产品详情 (按价格降序):");
        foreach (var detail in productDetails)
        {
            Console.WriteLine($"- {detail.Name} ({detail.CategoryName}), 价格: {detail.Price:C}");
        }
    }
}

登录后复制

这个例子展示了

Where

登录后复制

用于筛选，

GroupBy

登录后复制

用于分组，以及

join

登录后复制

和

orderby

登录后复制

在查询语法中的应用。这只是冰山一角，LINQ还提供了大量操作符来满足各种复杂的数据查询需求。

LINQ查询的常见语法模式有哪些？

LINQ查询主要有两种语法模式，它们各有千秋，在实际开发中我发现大家的选择往往取决于个人习惯和团队规范。一种是“查询语法”（Query Syntax），它看起来很像SQL，对于习惯数据库操作的开发者来说非常直观；另一种是“方法语法”（Method Syntax）或称“链式调用”，它利用C#的扩展方法，以链式调用的形式组织查询，更符合C#面向对象的风格。

1. 查询语法 (Query Syntax) 这种语法以

from

登录后复制

子句开头，后面跟着一系列类似SQL的关键字，如

Where

登录后复制

、

orderby

登录后复制

、

group by

登录后复制

、

join

登录后复制

和

select

登录后复制

。它的可读性很高，尤其是在处理多表联接或复杂分组时，结构会显得比较清晰。

// 查询语法示例：查找所有价格在50到200之间的产品，并按名称排序
var querySyntaxProducts = from p in products
                          where p.Price >= 50 && p.Price <= 200
                          orderby p.Name ascending
                          select p;

Console.WriteLine("查询语法示例 (价格在50到200之间的产品):");
foreach (var p in querySyntaxProducts)
{
    Console.WriteLine($"- {p.Name} ({p.Price:C})");
}

登录后复制

我个人觉得，当查询逻辑变得比较复杂，比如需要多个

join

登录后复制

或者嵌套

group by

登录后复制

时，查询语法能让代码结构更一目了然。

2. 方法语法 (Method Syntax / Chain Syntax) 这种语法是基于扩展方法实现的，它将LINQ操作符作为方法调用，通过点号

登录后复制

将它们串联起来，形成一个方法链。对于熟悉C#方法调用的开发者来说，这种方式可能感觉更自然，也更灵活，因为你可以轻松地将LINQ表达式与其他C#方法混合使用。

// 方法语法示例：查找所有价格在50到200之间的产品，并按名称排序
var methodSyntaxProducts = products.Where(p => p.Price >= 50 && p.Price <= 200)
                                   .OrderBy(p => p.Name);

Console.WriteLine("\n方法语法示例 (价格在50到200之间的产品):");
foreach (var p in methodSyntaxProducts)
{
    Console.WriteLine($"- {p.Name} ({p.Price:C})");
}

登录后复制

很多时候，我发现方法语法在处理一些简单筛选和投影时会更简洁。而且，有些LINQ操作符，比如

FirstOrDefault()

登录后复制

、

Any()

登录后复制

、

Count()

登录后复制

等，只能通过方法语法来使用。实际项目中，这两种语法常常是混用的，比如先用查询语法进行复杂联接，然后用方法语法进行聚合操作。理解它们的等价性并灵活运用，是掌握LINQ的关键。

为什么我应该在我的C#项目中使用LINQ？它能解决什么痛点？

这问题问得好，因为任何技术的引入都应该有其价值所在。我记得在我刚接触LINQ之前，处理数据集合简直是一场噩梦。想象一下，你要从一个大列表中找出所有符合特定条件的对象，然后对它们进行排序，再把某些属性提取出来形成新的结构。以前，你可能得写一堆

foreach

登录后复制

循环，里面套着

if

登录后复制

判断，然后手动创建新列表来存储结果，代码又长又容易出错，而且可读性极差。LINQ的出现，可以说完美解决了这些痛点。

1. 代码更简洁、可读性更高： 这是我最直观的感受。LINQ允许你用声明式的方式表达“你想要什么”，而不是“你如何去做”。例如，

products.Where(p => p.Price > 100).OrderBy(p => p.Name)

登录后复制

比一个手动循环和排序的代码块要清晰得多，它直接表达了意图。这让维护代码变得轻松，新来的同事也能更快理解业务逻辑。

2. 统一的数据查询模型： 不管是内存中的

List<T>

登录后复制

、数据库的

IQueryable<T>

登录后复制

、XML文档，甚至是ADO.NET

DataSet

登录后复制

，LINQ都提供了一套统一的查询接口。这意味着你不需要为每种数据源学习一套新的查询API或语言（比如SQL、XPath），大大降低了学习成本和开发复杂性。这种“一招鲜吃遍天”的感觉，对于开发者来说简直是福音。

3. 编译时类型安全： 这是LINQ一个非常重要的优势。当你编写SQL字符串时，如果SQL语法有错或者字段名写错，只有在运行时执行到那段代码时才会报错。而LINQ查询是在C#代码中直接操作类型化的对象，IDE可以在编译时就检查出语法错误和类型不匹配的问题。这能极大地减少运行时错误，提高代码的健壮性。

4. 强大的扩展性和可组合性： LINQ查询是可组合的。你可以将多个LINQ操作符链式地组合起来，构建出非常复杂的查询逻辑。而且，由于它是基于扩展方法构建的，你甚至可以编写自己的LINQ扩展方法，来封装特定的业务逻辑，让代码更具复用性。

5. 延迟执行（Deferred Execution）： 大多数LINQ查询默认是延迟执行的，这意味着查询定义本身并不会立即执行，而是在你真正需要结果时（比如遍历

foreach

登录后复制

或调用

ToList()

登录后复制

）才执行。这带来了巨大的性能优势，因为它允许LINQ提供者（如Entity Framework）在执行前对查询进行优化，比如将多个操作合并成一个更高效的SQL查询，或者只从数据库中获取所需的数据，避免了不必要的数据传输。

蓝心千询

蓝心千询是vivo推出的一个多功能AI智能助手

查看详情

简而言之，LINQ将数据查询从一个繁琐、易错、分散的任务，变成了一个优雅、类型安全、统一且高效的编程体验。它解放了开发者，让他们可以更专注于业务逻辑，而不是底层的数据操作细节。

LINQ查询性能优化有哪些技巧和注意事项？

虽然LINQ让数据查询变得优雅，但如果使用不当，也可能成为性能瓶颈。我见过不少项目，因为对LINQ的内部机制理解不足，导致查询效率低下。所以，了解一些优化技巧和注意事项是很有必要的。

1. 理解延迟执行与即时执行： 这是LINQ性能优化的基石。

延迟执行（Deferred Execution）：大多数LINQ查询操作符（如
```
Where
```
登录后复制
,
```
select
```
登录后复制
,
```
orderby
```
登录后复制
,
```
join
```
登录后复制
等）都是延迟执行的。它们仅仅构建了一个查询表达式树，而不会立即执行查询并获取结果。查询只会在你真正需要数据时（例如，通过
```
foreach
```
登录后复制
遍历结果、调用
```
ToList()
```
登录后复制
,
```
ToArray()
```
登录后复制
,
```
ToDictionary()
```
登录后复制
等方法，或者使用
```
Count()
```
登录后复制
,
```
Sum()
```
登录后复制
,
```
Average()
```
登录后复制
等聚合函数）才会被执行。
即时执行（Immediate Execution）：
```
ToList()
```
登录后复制
,
```
ToArray()
```
登录后复制
,
```
ToDictionary()
```
登录后复制
,
```
Count()
```
登录后复制
,
```
Sum()
```
登录后复制
,
```
Average()
```
登录后复制
等方法会强制查询立即执行，并将结果加载到内存中。 优化建议： 尽量利用延迟执行的特性。只在必要时才将查询结果具体化。如果一个查询结果会被多次使用，或者你需要在内存中操作它，那么调用
```
ToList()
```
登录后复制
或
```
ToArray()
```
登录后复制
一次性加载是合理的。但如果只是为了遍历一次，就不必额外调用。

2. 尽早过滤数据： 这是一个非常经典的优化原则，无论是在LINQ还是SQL中都适用。在查询链中，

Where

登录后复制

子句应该尽可能地放在前面，这样可以减少后续操作需要处理的数据量。

// 差的实践：先获取所有数据，再在内存中过滤
// var expensiveProducts = products.ToList().Where(p => p.Price > 100); 
// 好的实践：在数据源层面就进行过滤
var expensiveProducts = products.Where(p => p.Price > 100); // 如果是IQueryable，会转换为SQL的WHERE子句

登录后复制

特别是对于

IQueryable

登录后复制

（如Entity Framework），将

Where

登录后复制

放在前面意味着生成的SQL查询会包含

Where

登录后复制

子句，数据库会直接返回更少的数据，大大减少了网络传输和内存开销。

3. 避免在循环中重复执行查询： 这是一个常见的陷阱。如果你在一个循环内部定义并执行LINQ查询，那么每次循环迭代都会重新执行查询，这会造成巨大的性能浪费。

// 差的实践：在循环中反复查询数据库或大型集合
foreach (var item in someOtherCollection)
{
    var relatedData = dbContext.RelatedItems.Where(ri => ri.ParentId == item.Id).ToList(); // 每次循环都查
    // ...处理relatedData
}

// 好的实践：提前加载所有相关数据，或一次性查询
var allRelatedData = dbContext.RelatedItems.Where(ri => someOtherCollection.Select(item => item.Id).Contains(ri.ParentId)).ToList();
foreach (var item in someOtherCollection)
{
    var relatedData = allRelatedData.Where(ri => ri.ParentId == item.Id); // 从内存中过滤
    // ...处理relatedData
}

登录后复制

对于数据库查询，这尤其重要，因为它可能导致臭名昭著的N+1查询问题。

4. 谨慎使用

AsEnumerable()

登录后复制

和
AsQueryable()
登录后复制
：

```
AsEnumerable()
```
登录后复制
：会将后续的LINQ操作从
```
IQueryable
```
登录后复制
上下文切换到
```
IEnumerable
```
登录后复制
上下文。这意味着从
```
AsEnumerable()
```
登录后复制
之后的操作将在内存中执行，而不是转换为SQL在数据库中执行。如果你需要使用一些数据库不支持的C#方法，这很有用，但要确保在此之前已经过滤了足够的数据，否则可能导致大量数据被加载到内存。
```
AsQueryable()
```
登录后复制
：通常用于将
```
IEnumerable
```
登录后复制
转换为
```
IQueryable
```
登录后复制
，以便利用
```
IQueryable
```
登录后复制
的特性（如表达式树和远程执行）。但在从数据库上下文中获取数据时，通常不需要显式调用它，因为Entity Framework等ORM会默认返回
```
IQueryable
```
登录后复制
。

5. 关注投影（

select

登录后复制

）的效率： 只选择你真正需要的列，而不是选择整个对象。

// 差的实践：获取整个产品对象，即使你只需要名称和价格
var allProducts = products.ToList(); // 如果是数据库，会加载所有列

// 好的实践：只投影需要的属性
var productNamesAndPrices = products.Select(p => new { p.Name, p.Price }).ToList();

登录后复制

这对于数据库查询尤其重要，因为它能减少从数据库传输到应用程序的数据量。

6. 避免复杂表达式的翻译问题： 有些复杂的C#表达式，特别是自定义方法或复杂的业务逻辑，可能无法被LINQ提供者（如Entity Framework）正确地翻译成SQL。这会导致LINQ提供者将数据加载到内存中，然后在内存中执行这些操作。 优化建议： 尽量使用LINQ提供者能够理解的简单表达式。如果必须使用复杂逻辑，考虑先在数据库层面过滤大部分数据，然后使用