C# 中 LINQ 常用的扩展方法有哪些 (如：Where, Select, OrderBy)？

推荐答案

在C#中，LINQ（Language Integrated Query）提供了许多常用的扩展方法，用于对集合进行查询和操作。以下是一些常用的LINQ扩展方法：

• Where: 用于过滤集合中的元素，返回满足条件的元素。
• Select: 用于将集合中的每个元素投影到新的形式。
• OrderBy: 用于按升序对集合中的元素进行排序。
• OrderByDescending: 用于按降序对集合中的元素进行排序。
• GroupBy: 用于根据指定的键对集合中的元素进行分组。
• Join: 用于根据两个集合中的共同键将它们连接起来。
• Distinct: 用于从集合中移除重复的元素。
• Any: 用于判断集合中是否存在满足条件的元素。
• All: 用于判断集合中的所有元素是否都满足条件。
• First: 用于返回集合中的第一个元素。
• FirstOrDefault: 用于返回集合中的第一个元素，如果集合为空则返回默认值。
• Single: 用于返回集合中的唯一元素，如果集合为空或包含多个元素则抛出异常。
• SingleOrDefault: 用于返回集合中的唯一元素，如果集合为空则返回默认值，如果集合包含多个元素则抛出异常。
• Count: 用于返回集合中元素的数量。
• Sum: 用于计算集合中数值元素的总和。
• Average: 用于计算集合中数值元素的平均值。
• Min: 用于返回集合中的最小值。
• Max: 用于返回集合中的最大值。
• Take: 用于从集合的开头返回指定数量的元素。
• Skip: 用于跳过集合中指定数量的元素，并返回剩余的元素。
• TakeWhile: 用于从集合的开头返回满足条件的元素，直到遇到第一个不满足条件的元素为止。
• SkipWhile: 用于跳过集合中满足条件的元素，直到遇到第一个不满足条件的元素为止。
• Concat: 用于将两个集合连接在一起。
• Union: 用于返回两个集合的并集，移除重复的元素。
• Intersect: 用于返回两个集合的交集。
• Except: 用于返回两个集合的差集。

本题详细解读

LINQ是C#中非常强大的功能，它允许开发者以声明式的方式对集合进行查询和操作。LINQ扩展方法是通过扩展方法语法实现的，这意味着它们可以被直接应用于任何实现了IEnumerable<T>接口的集合。

Where

Where方法用于过滤集合中的元素。它接受一个谓词（即一个返回布尔值的函数），并返回满足该谓词的所有元素。

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(n => n % 2 == 0);
// evenNumbers 包含 2, 4

Select

Select方法用于将集合中的每个元素投影到新的形式。它接受一个转换函数，并返回转换后的元素。

var numbers = new List<int> { 1, 2, 3 };
var squaredNumbers = numbers.Select(n => n * n);
// squaredNumbers 包含 1, 4, 9

OrderBy

OrderBy方法用于按升序对集合中的元素进行排序。它接受一个键选择器函数，并返回按该键排序后的元素。

var numbers = new List<int> { 3, 1, 4, 1, 5 };
var sortedNumbers = numbers.OrderBy(n => n);
// sortedNumbers 包含 1, 1, 3, 4, 5

GroupBy

GroupBy方法用于根据指定的键对集合中的元素进行分组。它返回一个IGrouping<TKey, TElement>的集合，其中每个分组包含具有相同键的元素。

var words = new List<string> { "apple", "banana", "cherry", "date" };
var groupedWords = words.GroupBy(w => w.Length);
// groupedWords 包含两个分组：长度为5的 "apple" 和 "cherry"，长度为6的 "banana" 和 "date"

Join

Join方法用于根据两个集合中的共同键将它们连接起来。它返回一个包含匹配元素的新集合。

var customers = new List<Customer> { /* ... */ };
var orders = new List<Order> { /* ... */ };
var customerOrders = customers.Join(orders, c => c.Id, o => o.CustomerId, (c, o) => new { c.Name, o.OrderDate });
// customerOrders 包含每个客户及其订单日期的匿名对象

Distinct

Distinct方法用于从集合中移除重复的元素。它返回一个包含唯一元素的新集合。

var numbers = new List<int> { 1, 2, 2, 3, 4, 4, 5 };
var uniqueNumbers = numbers.Distinct();
// uniqueNumbers 包含 1, 2, 3, 4, 5

Any

Any方法用于判断集合中是否存在满足条件的元素。它返回一个布尔值，表示集合中是否存在满足条件的元素。

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var hasEvenNumber = numbers.Any(n => n % 2 == 0);
// hasEvenNumber 为 true

All

All方法用于判断集合中的所有元素是否都满足条件。它返回一个布尔值，表示集合中的所有元素是否都满足条件。

var numbers = new List<int> { 2, 4, 6, 8, 10 };
var allEven = numbers.All(n => n % 2 == 0);
// allEven 为 true

First

First方法用于返回集合中的第一个元素。如果集合为空，则抛出异常。

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var firstNumber = numbers.First();
// firstNumber 为 1

FirstOrDefault

FirstOrDefault方法用于返回集合中的第一个元素，如果集合为空则返回默认值。

var numbers = new List<int>();
var firstNumber = numbers.FirstOrDefault();
// firstNumber 为 0（int的默认值）

Single

Single方法用于返回集合中的唯一元素。如果集合为空或包含多个元素，则抛出异常。

var numbers = new List<int> { 42 };
var singleNumber = numbers.Single();
// singleNumber 为 42

SingleOrDefault

SingleOrDefault方法用于返回集合中的唯一元素，如果集合为空则返回默认值，如果集合包含多个元素则抛出异常。

var numbers = new List<int>();
var singleNumber = numbers.SingleOrDefault();
// singleNumber 为 0（int的默认值）

Count

Count方法用于返回集合中元素的数量。

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var count = numbers.Count();
// count 为 5

Sum

Sum方法用于计算集合中数值元素的总和。

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var sum = numbers.Sum();
// sum 为 15

Average

Average方法用于计算集合中数值元素的平均值。

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var average = numbers.Average();
// average 为 3

Min

Min方法用于返回集合中的最小值。

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var min = numbers.Min();
// min 为 1

Max

Max方法用于返回集合中的最大值。

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var max = numbers.Max();
// max 为 5

Take

Take方法用于从集合的开头返回指定数量的元素。

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var firstThreeNumbers = numbers.Take(3);
// firstThreeNumbers 包含 1, 2, 3

Skip

Skip方法用于跳过集合中指定数量的元素，并返回剩余的元素。

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var lastTwoNumbers = numbers.Skip(3);
// lastTwoNumbers 包含 4, 5

TakeWhile

TakeWhile方法用于从集合的开头返回满足条件的元素，直到遇到第一个不满足条件的元素为止。

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var numbersLessThanFour = numbers.TakeWhile(n => n < 4);
// numbersLessThanFour 包含 1, 2, 3

SkipWhile

SkipWhile方法用于跳过集合中满足条件的元素，直到遇到第一个不满足条件的元素为止。

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var numbersGreaterThanTwo = numbers.SkipWhile(n => n < 3);
// numbersGreaterThanTwo 包含 3, 4, 5

Concat

Concat方法用于将两个集合连接在一起。

var numbers1 = new List<int> { 1, 2, 3 };
var numbers2 = new List<int> { 4, 5, 6 };
var combinedNumbers = numbers1.Concat(numbers2);
// combinedNumbers 包含 1, 2, 3, 4, 5, 6

Union

Union方法用于返回两个集合的并集，移除重复的元素。

var numbers1 = new List<int> { 1, 2, 3 };
var numbers2 = new List<int> { 3, 4, 5 };
var uniqueNumbers = numbers1.Union(numbers2);
// uniqueNumbers 包含 1, 2, 3, 4, 5

Intersect

Intersect方法用于返回两个集合的交集。

var numbers1 = new List<int> { 1, 2, 3 };
var numbers2 = new List<int> { 3, 4, 5 };
var commonNumbers = numbers1.Intersect(numbers2);
// commonNumbers 包含 3

Except

Except方法用于返回两个集合的差集。

var numbers1 = new List<int> { 1, 2, 3 };
var numbers2 = new List<int> { 3, 4, 5 };
var difference = numbers1.Except(numbers2);
// difference 包含 1, 2