你知道什么时候在C#中使用 yield关键字吗？

当我们需要返回值而不遍历整个序列时，yield 很有用。这在许多不同的场景中可能是有益的。我们将看到一个基本示例，然后是另一个具有真实生活场景的示例。

注意：您可以使用您最喜欢的在线 C# 编译器（如 ShartLab.io）尝试本文中显示的示例。

示例 1：使用 yield，从前 100 万个数字打印偶数。

没有屈服

以下是解决上述要求的一种方法：

using System;
using System.Collections.Generic;

var num = GetEvenNumbers(10);// change it to simulate one million
foreach(int n in num){
    Console.WriteLine(n);
}

static IEnumerable<int> GetEvenNumbers(int max){
    List<int> numbers = new List<int>();
    for (int i = 0; i < max; i++){
        if (i % 2 == 0){
            numbers.Add(i);
        }
    }
    return numbers;
}

解释：

我们创建了函数，该函数将返回提供的最大数字内的偶数列表。因此，如果我们提供 10 作为最大数字，则函数将返回 。

在得到数字之后，我们只需循环打印它们。foreach

但是，假设我们提供 100 万作为最大数字。在这种情况下，程序将需要更长的时间才能执行，实际上甚至需要更长的时间才能到达第一个语句。这是因为，函数将遍历一百万个数字，同时维护一个内部数字列表。

你看到问题了吗？用户必须等到程序完成所有计算。如果我们可以在计算时开始打印偶数，那会怎样？这正是帮助我们实现的目标。

以下是上述示例的修订版本（使用）：

using System;  
using System.Collections.Generic;  
  
var num = GetEvenNumbers(10);  
foreach(int n in num){  
    Console.WriteLine(n);  
}  
  
static IEnumerable<int> GetEvenNumbers(int max){  
      
    for (int i = 0; i < max; i++){  
        if (i % 2 == 0){  
            yield return i;  
  
        }  
    }  
}

解释：

如您所见，我们通过删除内部并返回到我们处于安全点的位置来更新函数。

在C#编译器甚至不会调用该函数。这是因为它正在返回产量。相反，当我们在循环中执行真正的迭代时，它将被调用。请注意，编译器将在使用 使用 迭代时跟踪 inside 函数的值，因为它会移入和移出。这使我们的程序更具响应性。

现在有了这种理解，让我们看看真实世界的例子。

假设我们有一个员工管理系统。在系统中，其中一个页面列出了员工。如果记录总数很小，那么就不会有任何问题。但是，考虑一家大公司，该列表可能包含数千名员工。如果页面尝试加载所有这些，则系统可能会遇到性能问题。

可以结合使用数据库分页和 来处理这种情况。下面是一个示例：

DBContext：

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

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

public class EmployeeDbContext
{
    private readonly List<Employee> _employee;

    public EmployeeDbContext()
    {
        // Simulate a database with 100 Employees
        _employee = Enumerable
                      .Range(1, 100)
                      .Select(i => new Employee { 
                            Id = i, 
                            Name = $"Employee {i}" })
                      .ToList();
    }

    public List<Employee> GetEmployees(int pageNumber, int pageSize)
    {
        return _employee
                .Skip((pageNumber - 1) * pageSize)
                .Take(pageSize)
                .ToList();
    }
}

在这里，我们模拟函数中有 100 名员工，并将根据页码和页面大小返回特定的员工集。EmployeeDbContextGetEmployees

接下来，我们有 Service 类，它将使用 DBContext 返回员工。

public class EmployeeService
{
    private readonly EmployeeDbContext _dbContext;

    public EmployeeService(EmployeeDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public IEnumerable<Employee> GetEmployees(int pageSize)
    {
        int pageNumber = 1;
        while (true)
        {
            var employees = _dbContext.GetEmployees(pageNumber, pageSize);
            if (employees.Count == 0)
                yield break;

            foreach (var employee in employees)
            {
                yield return employee;
            }

            pageNumber++;
        }
    }
}

public class Program
{
    public static void Main()
    {
        var dbContext = new EmployeeDbContext();
        var employeeService = new EmployeeService(dbContext);

        foreach (var empl in employeeService.GetEmployees(10))
        {
            Console.WriteLine($"Processing Employee: {empl.Name}");
        }
    }
}

Program 类中的 Main 函数，使用迭代器创建和调用。

在 中，我们从 DBConext 调用。请注意，它返回 yield。这将在处理每个员工时提高内存效率，而不会将所有员工加载到内存中。这样一来，yield + DB 分页将使我们的代码运行得更快，提高内存利用率。

此外，请注意，我们已用于模拟源为空的场景。

要运行此操作，您可以在编辑器中复制并粘贴这两个代码段 SharpLab.io。

Yield 最适合于我们迭代列表或序列，并且列表来自数据库或 API 响应的场景。yield 不是在内存中获取加载的所有数据，而是可以提高内存效率，对于实时数据处理方案非常有用。

如果你喜欢我的文章，请给我一个赞！谢谢