掌握LINQ：查询语法与方法语法全解析

冰茶_2025-05-19 12:24

文章目录

    • 引言
    • [1. 查询语法 vs 方法语法](#1. 查询语法 vs 方法语法)
      • [1.1 查询语法 (Query Syntax)](#1.1 查询语法 (Query Syntax))
      • [1.2 方法语法 (Method Syntax)](#1.2 方法语法 (Method Syntax))
      • [1.3 两种语法的比较](#1.3 两种语法的比较)
    • [2. 基本的 LINQ 查询结构](#2. 基本的 LINQ 查询结构)
      • [2.1 数据源](#2.1 数据源)
      • [2.2 查询操作](#2.2 查询操作)
      • [2.3 查询执行](#2.3 查询执行)
    • [3. 查询表达式中的关键字](#3. 查询表达式中的关键字)
      • [3.1 基本关键字](#3.1 基本关键字)
      • [3.2 其他常用关键字](#3.2 其他常用关键字)
    • [4. LINQ 中的 var 关键字与类型推断](#4. LINQ 中的 var 关键字与类型推断)
      • [4.1 var关键字的使用](#4.1 var关键字的使用)
      • [4.2 类型推断的工作原理](#4.2 类型推断的工作原理)
      • [4.3 类型推断的优缺点](#4.3 类型推断的优缺点)
    • [5. 实际应用示例](#5. 实际应用示例)
    • 总结
    • 进一步学习资源

引言

LINQ（Language Integrated Query，语言集成查询）是.NET平台上一种强大的查询语言技术，它允许开发者使用统一的语法对不同类型的数据源进行查询操作。无论是操作内存中的对象集合、数据库中的表，还是XML文档，开发者都可以使用相同的语法结构。

本文将详细介绍LINQ的基础语法，包括两种主要的语法风格、查询的基本结构、常用关键字以及类型推断机制，帮助你掌握LINQ的基本用法。

1. 查询语法 vs 方法语法

LINQ提供了两种编写查询的语法风格：查询语法 和方法语法。两者在功能上完全等价，最终都会被编译器转换为对扩展方法的调用，区别主要在于代码的表达方式和可读性。

1.1 查询语法 (Query Syntax)

查询语法类似于SQL语句，使用关键字如from、where、select等组织查询逻辑。这种语法对于有SQL经验的开发人员来说更加直观。

csharp 复制代码 
// 查询语法示例：查找所有长度大于5的字符串
// 首先定义一个字符串数组作为数据源
string[] fruits = { "apple", "banana", "orange", "grape", "watermelon", "kiwi" };

// 使用查询语法查找长度大于5的水果名称
var longFruits = from fruit in fruits
                where fruit.Length > 5
                orderby fruit
                select fruit;

// 遍历并输出结果
foreach (var fruit in longFruits)
{
    Console.WriteLine(fruit);
}
// 输出：
// banana
// orange
// watermelon

1.2 方法语法 (Method Syntax)

方法语法使用扩展方法和Lambda表达式，更加紧凑，有时能提供查询语法不支持的功能。对于有函数式编程经验的开发人员来说，这种语法可能更加自然。

csharp 复制代码 
// 方法语法示例：实现与上面相同的功能
string[] fruits = { "apple", "banana", "orange", "grape", "watermelon", "kiwi" };

// 使用方法语法查找长度大于5的水果名称
var longFruits = fruits
                .Where(fruit => fruit.Length > 5)  // 过滤条件
                .OrderBy(fruit => fruit)           // 排序
                .Select(fruit => fruit);           // 投影（这里没有改变，但可以在此处进行转换）

// 遍历并输出结果
foreach (var fruit in longFruits)
{
    Console.WriteLine(fruit);
}
// 输出与查询语法相同

1.3 两种语法的比较

LINQ语法选择 查询语法 方法语法 优点: SQL风格,可读性好 缺点: 部分高级操作不支持 优点: 紧凑,功能全面 缺点: 复杂查询可读性较差

特性 查询语法 方法语法
语法风格 类似SQL，声明式 链式方法调用
可读性 对于复杂查询更好 对于简单查询更好
功能覆盖 不支持部分高级操作 支持全部LINQ操作
适用场景 复杂的查询逻辑 简单查询或需要特殊操作
学习曲线 熟悉SQL的人更易上手 熟悉函数式编程的人更易上手

2. 基本的 LINQ 查询结构

LINQ查询通常包含以下几个主要部分：

2.1 数据源

每个LINQ查询都必须有一个数据源，它可以是数组、列表、字典或其他任何实现了IEnumerable<T>接口的集合。

csharp 复制代码 
// 数据源示例
List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // 列表
int[] numbersArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };              // 数组
Dictionary<string, int> ages = new Dictionary<string, int>            // 字典
{
    { "Alice", 25 },
    { "Bob", 30 },
    { "Charlie", 35 }
};

2.2 查询操作

查询操作定义了我们要对数据源执行的操作，如筛选、排序、分组等。

csharp 复制代码 
// 基本查询结构（查询语法）
var query = from element in dataSource   // 数据源和范围变量
            where condition              // 过滤条件（可选）
            orderby property             // 排序条件（可选）
            group element by key         // 分组条件（可选）
            select result;               // 结果选择

2.3 查询执行

LINQ查询通常采用延迟执行模式，这意味着查询定义和查询执行是分开的。查询只有在被枚举（如使用foreach循环）或调用强制执行方法（如ToList()）时才会执行。

csharp 复制代码 
// 定义查询（此时不会执行）
var evenNumbers = from n in numbers
                 where n % 2 == 0
                 select n;

// 执行查询的方式1：遍历结果
foreach (var num in evenNumbers)  // 此时查询被执行
{
    Console.WriteLine(num);
}

// 执行查询的方式2：强制立即执行
List<int> evenNumbersList = evenNumbers.ToList();  // 立即执行并将结果存储到列表中
int[] evenNumbersArray = evenNumbers.ToArray();    // 立即执行并将结果存储到数组中

3. 查询表达式中的关键字

查询语法中使用了一系列关键字来构建查询表达式。以下是最常用的关键字及其功能：

3.1 基本关键字

LINQ关键字 from where select/group by orderby join 指定数据源和范围变量 指定过滤条件 指定结果形式 指定排序方式 指定连接条件

from

定义查询的数据源和范围变量（迭代变量）。

csharp 复制代码 
// from关键字示例
// 创建学生类
public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

// 创建学生列表
List<Student> students = new List<Student>
{
    new Student { Id = 1, Name = "张三", Age = 18 },
    new Student { Id = 2, Name = "李四", Age = 20 },
    new Student { Id = 3, Name = "王五", Age = 19 }
};

// 使用from定义数据源和范围变量
var query = from student in students  // student是范围变量，students是数据源
            select student.Name;
where

指定过滤条件，类似SQL中的WHERE子句。

csharp 复制代码 
// where关键字示例
// 查询年龄大于18的学生
var adultStudents = from student in students
                   where student.Age > 18  // 使用where指定过滤条件
                   select student;

// 使用多个条件
var filteredStudents = from student in students
                      where student.Age > 18 && student.Name.StartsWith("李")  // 组合条件
                      select student;
select

将查询结果投影为指定的形式，可以是原始对象、新对象或单个属性。

csharp 复制代码 
// select关键字示例
// 选择学生姓名
var studentNames = from student in students
                  select student.Name;  // 选择单个属性

// 创建匿名类型
var studentInfo = from student in students
                 select new { student.Name, student.Age };  // 创建包含部分属性的匿名类型

// 创建新类型
var studentViewModels = from student in students
                       select new StudentViewModel  // 创建新的具名类型
                       {
                           FullName = student.Name,
                           YearsOld = student.Age
                       };
orderby

指定结果的排序方式，支持升序(默认)和降序，也支持多级排序。

csharp 复制代码 
// orderby关键字示例
// 按年龄升序排序
var sortedByAge = from student in students
                 orderby student.Age  // 默认为升序
                 select student;

// 按年龄降序排序
var sortedByAgeDesc = from student in students
                     orderby student.Age descending  // 使用descending指定降序
                     select student;

// 多级排序：先按年龄降序，再按姓名升序
var complexSort = from student in students
                 orderby student.Age descending, student.Name  // 多级排序
                 select student;
group by

根据指定的键对结果进行分组。

csharp 复制代码 
// group by关键字示例
// 按年龄分组
var groupedByAge = from student in students
                  group student by student.Age;  // 生成IGrouping<int, Student>集合

// 遍历分组结果
foreach (var group in groupedByAge)
{
    Console.WriteLine($"年龄: {group.Key}");  // 使用Key属性访问分组键
    foreach (var student in group)  // 遍历组内元素
    {
        Console.WriteLine($"  - {student.Name}");
    }
}

// 创建更复杂的分组结果
var customGroupResult = from student in students
                       group student by student.Age into ageGroup  // 使用into子句创建临时变量
                       select new
                       {
                           Age = ageGroup.Key,
                           Count = ageGroup.Count(),
                           Students = ageGroup.ToList()
                       };
join

实现两个数据源之间的连接，类似SQL中的JOIN操作。

csharp 复制代码 
// join关键字示例
// 创建课程类
public class Course
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int StudentId { get; set; }  // 外键，关联到学生
}

// 创建课程列表
List<Course> courses = new List<Course>
{
    new Course { Id = 1, Name = "数学", StudentId = 1 },
    new Course { Id = 2, Name = "语文", StudentId = 1 },
    new Course { Id = 3, Name = "英语", StudentId = 2 },
    new Course { Id = 4, Name = "物理", StudentId = 3 },
    new Course { Id = 5, Name = "化学", StudentId = 3 }
};

// 使用join连接学生和课程
var studentCourses = from student in students
                    join course in courses
                    on student.Id equals course.StudentId  // 指定连接条件
                    select new
                    {
                        StudentName = student.Name,
                        CourseName = course.Name
                    };

// 输出连接结果
foreach (var item in studentCourses)
{
    Console.WriteLine($"学生: {item.StudentName}, 课程: {item.CourseName}");
}

3.2 其他常用关键字

  • into: 用于创建查询的临时结果，通常与group by或join一起使用。
  • let: 在查询表达式中引入临时变量。
csharp 复制代码 
// let关键字示例
// 计算学生姓名长度并使用
var nameAnalysis = from student in students
                  let nameLength = student.Name.Length  // 定义临时变量
                  where nameLength > 1  // 使用临时变量
                  select new
                  {
                      student.Name,
                      NameLength = nameLength
                  };

4. LINQ 中的 var 关键字与类型推断

4.1 var关键字的使用

var关键字允许编译器自动推断变量的类型，无需显式指定。在LINQ中，var特别有用，因为查询结果的类型有时很复杂或难以预先确定。

csharp 复制代码 
// var关键字示例
// 不使用var（显式类型）
IEnumerable<string> names1 = from student in students
                           select student.Name;

// 使用var（隐式类型推断）
var names2 = from student in students
            select student.Name;  // 编译器推断为IEnumerable<string>

// 当结果是匿名类型时，必须使用var
var studentSummary = from student in students
                    select new { student.Name, NameLength = student.Name.Length };
// 无法使用显式类型，因为匿名类型没有名称

4.2 类型推断的工作原理

编译器根据右侧表达式推断变量的类型。在LINQ查询中，推断的类型取决于查询的结构和select子句的结果。

csharp 复制代码 
// 类型推断示例
// 1. 基本查询 - 推断为IEnumerable<T>，其中T是元素类型
var allStudents = from s in students select s;  // IEnumerable<Student>

// 2. 选择单个属性 - 推断为该属性类型的IEnumerable
var ages = from s in students select s.Age;  // IEnumerable<int>

// 3. 创建匿名类型 - 推断为匿名类型的IEnumerable
var studentInfo = from s in students
                 select new { s.Name, s.Age };  // IEnumerable<匿名类型>

// 4. 分组查询 - 推断为IEnumerable<IGrouping<K, T>>
var groupedStudents = from s in students
                     group s by s.Age;  // IEnumerable<IGrouping<int, Student>>

4.3 类型推断的优缺点

var关键字与类型推断 优点 缺点 代码简洁 处理复杂类型 处理匿名类型 可能降低代码可读性 IDE依赖性

优点：
  • 代码更简洁，减少冗余
  • 处理复杂的查询结果类型
  • 处理匿名类型（没有显式类型名）
  • 适应类型变化，减少修改
缺点：
  • 可能降低代码可读性，尤其对于不熟悉的开发者
  • 更依赖IDE的类型提示功能

5. 实际应用示例

下面通过一个综合示例，展示LINQ基础语法的实际应用：

csharp 复制代码 
using System;
using System.Collections.Generic;
using System.Linq;

namespace LinqBasicDemo
{
    // 产品类
    public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Category { get; set; }
        public decimal Price { get; set; }
        public int Stock { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 创建产品列表
            List<Product> products = new List<Product>
            {
                new Product { Id = 1, Name = "笔记本电脑", Category = "电子产品", Price = 5999, Stock = 10 },
                new Product { Id = 2, Name = "手机", Category = "电子产品", Price = 2999, Stock = 20 },
                new Product { Id = 3, Name = "耳机", Category = "配件", Price = 199, Stock = 100 },
                new Product { Id = 4, Name = "键盘", Category = "配件", Price = 299, Stock = 50 },
                new Product { Id = 5, Name = "鼠标", Category = "配件", Price = 99, Stock = 80 },
                new Product { Id = 6, Name = "显示器", Category = "电子产品", Price = 1299, Stock = 15 },
                new Product { Id = 7, Name = "平板电脑", Category = "电子产品", Price = 3599, Stock = 8 },
                new Product { Id = 8, Name = "充电器", Category = "配件", Price = 59, Stock = 200 }
            };

            Console.WriteLine("===== 使用查询语法 =====");

            // 1. 基本查询：价格超过1000元的产品
            Console.WriteLine("\n1. 价格超过1000元的产品：");
            var expensiveProducts = from p in products
                                   where p.Price > 1000
                                   orderby p.Price descending
                                   select p;
            
            foreach (var product in expensiveProducts)
            {
                Console.WriteLine($"{product.Name} - ¥{product.Price}");
            }

            // 2. 投影查询：选择部分属性
            Console.WriteLine("\n2. 产品名称和价格列表：");
            var productInfos = from p in products
                              select new { p.Name, p.Price };
            
            foreach (var info in productInfos)
            {
                Console.WriteLine($"{info.Name} - ¥{info.Price}");
            }

            // 3. 分组查询：按类别分组
            Console.WriteLine("\n3. 按类别分组的产品：");
            var groupedProducts = from p in products
                                 group p by p.Category into categoryGroup
                                 select new
                                 {
                                     Category = categoryGroup.Key,
                                     Count = categoryGroup.Count(),
                                     Products = categoryGroup.ToList()
                                 };
            
            foreach (var group in groupedProducts)
            {
                Console.WriteLine($"类别: {group.Category} (共{group.Count}个产品)");
                foreach (var product in group.Products)
                {
                    Console.WriteLine($"  - {product.Name} - ¥{product.Price}");
                }
            }

            Console.WriteLine("\n===== 使用方法语法 =====");

            // 4. 过滤和排序：查找库存少于20的产品并按库存升序排列
            Console.WriteLine("\n4. 库存少于20的产品（库存升序）：");
            var lowStockProducts = products
                                    .Where(p => p.Stock < 20)
                                    .OrderBy(p => p.Stock)
                                    .Select(p => p);
            
            foreach (var product in lowStockProducts)
            {
                Console.WriteLine($"{product.Name} - 库存: {product.Stock}");
            }

            // 5. 复杂查询：查找价格区间内的配件类产品，计算均价
            Console.WriteLine("\n5. 价格在50-300元的配件类产品：");
            var accessories = products
                               .Where(p => p.Category == "配件" && p.Price >= 50 && p.Price <= 300)
                               .ToList();
            
            decimal averagePrice = accessories.Average(p => p.Price);
            
            foreach (var accessory in accessories)
            {
                Console.WriteLine($"{accessory.Name} - ¥{accessory.Price}");
            }
            Console.WriteLine($"平均价格: ¥{averagePrice}");

            // 6. 组合查询：查找电子产品中最贵和最便宜的产品
            Console.WriteLine("\n6. 电子产品价格范围：");
            var electronicProducts = products.Where(p => p.Category == "电子产品");
            var mostExpensive = electronicProducts.OrderByDescending(p => p.Price).First();
            var cheapest = electronicProducts.OrderBy(p => p.Price).First();
            
            Console.WriteLine($"最贵产品: {mostExpensive.Name} - ¥{mostExpensive.Price}");
            Console.WriteLine($"最便宜产品: {cheapest.Name} - ¥{cheapest.Price}");
        }
    }
}

总结

LINQ的基础语法提供了一种强大而灵活的方式来处理各种数据源中的数据。通过掌握查询语法和方法语法，了解基本的查询结构和关键字，以及利用类型推断，你可以编写出简洁、可读性强的代码来实现复杂的数据操作。

LINQ的优势在于：

  1. 统一的查询语法：对不同数据源使用相同的查询结构
  2. 强类型和IDE支持：编译时类型检查和智能提示
  3. 可读性和表达力：声明式风格使代码意图更清晰
  4. 延迟执行：优化性能和资源使用
  5. 可组合性：查询可以轻松组合和重用

随着你对LINQ基础语法的熟悉，你将能够更有效地处理数据，编写出更简洁、更易维护的代码。

进一步学习资源

  1. Microsoft官方文档：LINQ (C#)

  2. .NET官方教程：LINQ查询操作

  3. LINQPad工具 - 学习和测试LINQ查询的实用工具

  4. GitHub: 101 LINQ示例

相关推荐
霸王蟹1 分钟前
React 19中如何向Vue那样自定义状态和方法暴露给父组件。
前端·javascript·学习·react.js·typescript
Dongwoo Jeong11 分钟前
UI架构的历史与基础入门
c#·mvc·mvvm·mvp·mvi·architecture
mascon12 分钟前
C#自定义扩展方法 及 EventHandler＜TEventArgs＞ 委托
开发语言·c#
Moonnnn.31 分钟前
【数字电路】第七章 脉冲波形的产生与整形电路
笔记·学习
猴子请来的逗比4891 小时前
tomcat查看状态页及调优信息
服务器·学习·tomcat·firefox
IvanCodes2 小时前
MySQL 数据库备份与还原
大数据·数据库·sql·mysql
贺函不是涵3 小时前
【沉浸式求职学习day43】【Java面试题精选3】
java·开发语言·学习
maray3 小时前
ETL 学习
数据仓库·学习·etl
海尔辛3 小时前
学习黑客Active Directory入门
学习·ad·window
superior tigre3 小时前
C++学习：六个月从基础到就业——C++20：协程(Coroutines)
c++·学习·c++20
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04Ubuntu24.04安装中文输入法05【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！06Coze扣子平台完整体验和实践（附国内和国际版对比）07组基轨迹建模 GBTM的介绍与实现（Stata 或 R）08YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU09DeepSeek各版本说明与优缺点分析10YOLOv8/YOLOv11改进 添加CBAM、GAM、SimAM、EMA、CAA、ECA、CA等多种注意力机制