C# 中的 LINQ语句可以使得我们使用简短的代码就可以完成排序、分类、查询等常用功能。以下是一些基本的 C# LINQ 使用案例：

1. 从数组或列表中查询元素**：

假设我们有一个整数数组，想要找出所有的偶数。

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2 };

var evenNumbers = numbers.Where(n => n % 2 == 0);

foreach (var number in evenNumbers)
{
    Console.WriteLine(number);
}

上述代码使用 Where 方法过滤出所有偶数。

2. 排序与分组：

如果我们有一个学生类 Student 包含 Name 和 Grade 属性，并且有一个学生列表，我们可以按年级排序并分组。

class Student
{
    public string Name { get; set; }
    public int Grade { get; set; }
}

List<Student> students = new List<Student>
{
    new Student { Name = "Alice", Grade = 9 },
    new Student { Name = "Bob", Grade = 10 },
    // 更多学生...
};

var sortedStudents = students.OrderBy(s => s.Grade);
var groupedStudents = students.GroupBy(s => s.Grade);

// 输出每个年级的学生
foreach (var group in groupedStudents)
{
    Console.WriteLine($"Grade: {group.Key}");
    foreach (var student in group)
    {
        Console.WriteLine($"\t{Name}:");
    }
}

3. 连接多个数据源：

这是一个复合查询的例子，假设我们有两个数据源：一个包含学生信息的列表和另一个包含课程成绩的列表，它们通过学生ID关联。

class Student
{
    public int ID { get; set; }
    public string Name { get; set; }
}

class Grade
{
    public int StudentID { get; set; }
    public string Course { get; set; }
    public double Score { get; set; }
}

List<Student> students = new List<Student>();
List<Grade> grades = new List<Grade>();

// 填充数据...

var studentGrades = from student in students
                    join grade in grades on student.ID equals grade.StudentID
                    select new { student.Name, grade.Course, grade.Score };

foreach (var item in studentGrades)
{
    Console.WriteLine($"{item.Name} 在 {item.Course} 的成绩是 {item.Score}");
}

4. 聚合操作：

计算列表中的总和、平均值、最大值或最小值。

var sum = numbers.Sum();
var average = numbers.Average();
var max = numbers.Max();
var min = numbers.Min();

Console.WriteLine($"Sum: {sum}, Average: {average}, Max: {max}, Min: {min}");

5. 分页查询：

假设我们有一个大型的用户列表，并希望分页显示。

class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    // 更多属性...
}

List<User> users = new List<User>(); // 假设有大量用户数据

int pageSize = 10;
int currentPage = 2;

var paginatedUsers = users.Skip((currentPage - 1) * pageSize).Take(pageSize);

foreach (var user in paginatedUsers)
{
    Console.WriteLine($"{user.Id}: {user.Name}");
}

6. 多条件查询：

对于一个包含产品信息的列表，我们可以根据多个条件进行筛选。

class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public bool IsAvailable { get; set; }
}

List<Product> products = new List<Product>();

var filteredProducts = products
    .Where(p => p.IsAvailable && p.Price > 100m && p.Name.Contains("Smartphone"))
    .OrderByDescending(p => p.Price);

foreach (var product in filteredProducts)
{
    Console.WriteLine($"{product.Name} - ${product.Price}");
}

7. 转换和投影（Select）：

只选择或转换对象中的某些属性。

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
}

List<Person> people = new List<Person>();

var personNames = people.Select(p => $"{p.FirstName} {p.LastName}");

foreach (var name in personNames)
{
    Console.WriteLine(name);
}

8. 聚合函数（GroupBy 和 Aggregate）：

计算每个类别（如按年龄分组）的数量，或者对一组值应用累计计算。

var ageGroups = people.GroupBy(p => p.Age)
                      .Select(g => new { Age = g.Key, Count = g.Count() });

foreach (var group in ageGroups)
{
    Console.WriteLine($"Age: {group.Age}, Count: {group.Count}");
}

double totalAge = people.Sum(p => p.Age);
Console.WriteLine($"Total age of all people: {totalAge}");

int oldestPersonAge = people.Aggregate((currentMax, next) => currentMax.Age > next.Age ? currentMax : next).Age;
Console.WriteLine($"Oldest person's age: {oldestPersonAge}");

9. 组合查询（Concat）：

将两个数据源合并为一个。

List<int> numbers1 = new List<int> { 1, 2, 3 };
List<int> numbers2 = new List<int> { 4, 5, 6 };

var combinedNumbers = numbers1.Concat(numbers2);

foreach (var number in combinedNumbers)
{
    Console.WriteLine(number);
}

10. Distinct 查询：

删除重复项，返回唯一值的序列。

```csharp
List<string> words = new List<string> { "apple", "banana", "apple", "orange", "banana" };

var uniqueWords = words.Distinct();

foreach (var word in uniqueWords)
{
    Console.WriteLine(word);
}
```

11. 元素存在性检查（Any 和 All）：

检查集合中是否存在满足条件的任何元素或所有元素都满足条件。

```csharp
bool hasEvenNumber = numbers.Any(n => n % 2 == 0);
Console.WriteLine($"是否有偶数：{hasEvenNumber}");

bool allNumbersGreaterThanZero = numbers.All(n => n > 0);
Console.WriteLine($"是否所有数字都大于零：{allNumbersGreaterThanZero}");
```

12. Join 多个数据源：

假设我们有两个不同类型的列表，通过某个公共属性关联它们。

```csharp
class Order
{
    public int CustomerId { get; set; }
    public decimal TotalPrice { get; set; }
}

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

List<Order> orders = new List<Order>();
List<Customer> customers = new List<Customer>();

var customerOrders = from order in orders
                     join customer in customers on order.CustomerId equals customer.Id
                     select new { CustomerName = customer.Name, OrderTotal = order.TotalPrice };

foreach (var item in customerOrders)
{
    Console.WriteLine($"{item.CustomerName} 的订单总价是 ${item.OrderTotal}");
}
```

以上就是更多关于C# LINQ使用的案例，实际上LINQ的功能远不止这些，它能极大地简化和优化对各种数据源的操作。

python学习汇总连接：
50个开发必备的Python经典脚本(1-10)

50个开发必备的Python经典脚本(11-20)

50个开发必备的Python经典脚本(21-30)

50个开发必备的Python经典脚本(31-40)

50个开发必备的Python经典脚本(41-50)
————————————————

​最后我们放松一下眼睛