yield关键字的底层运行机制

你一身傲骨怎能输

已于 2024-10-11 04:39:06 修改

阅读量307

点赞数 5

分类专栏： c# 文章标签： c#

于 2024-10-11 04:23:27 首次发布

本文链接：https://blog.csdn.net/qq_33060405/article/details/142836580

版权

c# 专栏收录该内容

22 篇文章 1 订阅

订阅专栏

yield 关键字在 C# 中用于创建迭代器，它允许方法在执行过程中暂停并返回一个值，然后在下次调用时从暂停的地方继续执行。yield 关键字的底层运行机制涉及到编译器生成的状态机。

1. 迭代器方法的编译

当你在方法中使用 yield return 或 yield break 时，编译器会将这个方法转换为一个迭代器类。这个类实现了 IEnumerable<T> 和 IEnumerator<T> 接口，允许方法以迭代的方式返回值。

2. 状态机的生成

编译器生成的迭代器类包含以下组件：

状态字段：用于跟踪方法的执行状态。
当前值字段：用于存储 yield return 返回的值。
MoveNext 方法：实现 IEnumerator.MoveNext 方法，控制方法的执行流程。
Current 属性：实现 IEnumerator.Current 属性，返回当前的值。

3. 执行流程

当你调用一个包含 yield 的方法时，以下是底层的执行流程：

创建迭代器对象：调用方法时，编译器生成的迭代器类被实例化。
调用 MoveNext 方法：每次调用 MoveNext 方法时，迭代器根据当前状态执行相应的代码，直到遇到 yield return 语句。
返回当前值：在 yield return 处，当前值被存储，并且 MoveNext 方法返回 true，表示有下一个值。
暂停执行：方法在此处暂停，保存当前的执行状态。
恢复执行：下次调用 MoveNext 方法时，从上次暂停的地方继续执行，直到遇到下一个 yield return 或方法结束。

4. 示例

考虑以下使用 yield 的方法：

public IEnumerable<int> GetNumbers()
{
    for (int i = 0; i < 5; i++)
    {
        yield return i;
    }
}

编译器会生成类似以下的迭代器类：

public class GetNumbersIterator : IEnumerable<int>, IEnumerator<int>
{
    private int state = -1;
    private int current;

    public int MoveNext()
    {
        switch (state)
        {
            case -1:
                state = 0;
                current = 0;
                break;
            case 0:
                if (current < 5)
                {
                    current++;
                }
                else
                {
                    return false;
                }
                break;
        }
        state++;
        return true;
    }

    public int Current => current;

    // 其他必要的方法和属性
}

5. 总结

yield 关键字通过编译器生成的状态机实现迭代器行为。
迭代器类包含状态字段、当前值字段、MoveNext 方法和 Current 属性。
每次调用 MoveNext 方法时，迭代器根据当前状态执行代码，直到遇到 yield return。

通过这种方式，yield 关键字提供了一种高效且简洁的方法来创建迭代器，允许方法以流式的方式返回值，而不需要一次性计算所有值。

yield break语句的执行流程是什么

yield break语句用于提前终止一个包含yield return的迭代器方法。当执行到yield break时，迭代器方法会立即停止执行，并且在下一次调用MoveNext()方法时返回false，表示没有更多的元素可以迭代。

以下是yield break语句的执行流程：

1. 迭代器方法的执行

当你调用一个包含yield return的迭代器方法时，该方法会返回一个迭代器对象。
迭代器对象的MoveNext()方法被调用以开始迭代过程。

2. 遇到 `yield return`

在迭代过程中，每次调用MoveNext()方法时，迭代器方法会从上次暂停的地方继续执行。
当遇到yield return语句时，当前迭代的值被返回，并且迭代器方法暂停执行，保存当前的执行状态。

3. 遇到 `yield break`

如果在迭代过程中遇到yield break语句，迭代器方法会立即停止执行。
迭代器的状态会被设置为表示迭代结束的状态（通常是-1）。

4. 下一次调用 `MoveNext()`

当再次调用迭代器的MoveNext()方法时，由于迭代器已经处于结束状态，MoveNext()方法会返回false。
这表示迭代器中没有更多的元素可以返回，迭代过程结束。

示例代码

下面是一个简单的示例，展示了yield break的使用和执行流程：

public IEnumerable<int> GetNumbers(int max)
{
    for (int i = 0; i < 10; i++)
    {
        if (i >= max)
        {
            yield break;
        }
        yield return i;
    }
}

// 使用迭代器
foreach (int number in GetNumbers(5))
{
    Console.WriteLine(number);
}

在这个例子中：

当i小于max时，yield return i会返回当前的值，并且方法暂停。
当i等于或大于max时，yield break会终止迭代。
在foreach循环中，当MoveNext()返回false时，循环结束。

总结

yield break用于提前终止迭代器方法的执行。
当遇到yield break时，迭代器方法停止执行，并设置状态为结束状态。
下一次调用MoveNext()时返回false，表示没有更多的元素可以迭代。

通过这种方式，yield break提供了一种简洁的方法来控制迭代器方法的执行流程，允许在满足特定条件时提前终止迭代。

yield关键字在函数中如何实现延迟执行？

在C#中，yield关键字用于创建迭代器（Iterator）方法，允许方法返回一个序列的值而不必将所有值都存储在内存中。yield关键字通常与yield return一起使用，实现延迟执行。

使用`yield return`实现延迟执行

当在方法中使用yield return时，该方法会变成一个迭代器方法。每次调用yield return时，它会返回当前的值，并在下一次调用时从上次离开的地方继续执行。

示例：使用`yield return`实现一个简单的迭代器

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

public class Example
{
    public IEnumerable<int> GetNumbers()
    {
        for (int i = 0; i < 5; i++)
        {
            yield return i;
        }
    }
}

// 使用迭代器
Example example = new Example();
foreach (int number in example.GetNumbers())
{
    Console.WriteLine(number);
}

在这个例子中，GetNumbers方法是一个迭代器方法，每次调用yield return时，它会返回当前的值，并在下一次调用时从上次离开的地方继续执行。

延迟执行的实现原理

在C#中，使用yield关键字的方法会被编译器转换为一个状态机。每次调用yield return时，方法的状态会被保存，下次调用时从上次离开的地方继续执行。

示例：编译器生成的迭代器类

以下是一个简化的示例，展示了编译器如何将使用yield关键字的方法转换为状态机：

public class Example
{
    public IEnumerable<int> GetNumbers()
    {
        int state = 0;
        while (state < 5)
        {
            yield return state++;
        }
    }
}

编译器会将上述代码转换为类似以下的迭代器类：

public class Example/<GetNumbers>d__0 : IEnumerable<int>, IEnumerable, IEnumerator<int>, IDisposable
{
    private int <>1__state;
    private int <>2__current;

    public int MoveNext()
    {
        switch (<>1__state)
        {
            case 0:
                <>1__state = -1;
                <>2__current = 0;
                <>1__state = 1;
                return true;
            case 1:
                <>1__state = -1;
                if (++<>2__current < 5)
                {
                    return true;
                }
                break;
        }
        return false;
    }

    public int Current
    {
        get { return <>2__current; }
    }

    // 其他必要的方法和属性
}

通过这种方式，yield关键字允许方法以一种高效的方式返回序列的值，而不必将所有值都存储在内存中。

总结

yield return用于创建迭代器方法，返回一个序列的值。
yield break用于提前终止迭代。
使用yield关键字的方法会被编译器转换为一个状态机，以实现高效的迭代器行为。

通过使用yield关键字，可以编写更简洁、高效的代码，特别是在处理大量数据或需要异步操作的场景中。

yield关键字是否会影响方法的性能？

yield关键字在C#中用于创建迭代器方法，允许方法返回一个序列的值而不必将所有值都存储在内存中。yield关键字的性能影响取决于具体的使用场景和实现方式。

正面影响

内存效率：yield return允许方法以流式的方式返回值，而不需要一次性计算所有值并存储在内存中。这对于处理大量数据或无限序列非常有用，可以显著减少内存占用。
延迟执行：yield return实现了延迟执行，只有在需要时才计算下一个值。这可以提高性能，特别是在处理耗时操作或I/O操作时。

负面影响

迭代器开销：使用yield关键字的方法会被编译器转换为一个迭代器类，每次调用MoveNext()方法时会有额外的开销。对于非常小的数据集，这种开销可能会稍微影响性能。
状态管理：迭代器方法的状态管理会引入一些额外的复杂性和开销。每次调用MoveNext()时，迭代器需要保存和恢复执行状态。

性能测试和分析

基准测试：在实际应用中，应该通过基准测试来评估yield关键字的性能影响。比较使用和不使用yield关键字的实现方式，特别是在处理不同大小的数据集时。
分析工具：使用性能分析工具（如Visual Studio Profiler、dotTrace等）来识别和解决性能瓶颈。

最佳实践

合理使用：在处理大量数据或需要延迟执行的场景中使用yield关键字。
避免过度使用：对于非常小的数据集，直接返回集合可能更高效，避免不必要的迭代器开销。
优化代码：确保迭代器方法的实现尽可能高效，避免不必要的计算和内存分配。

示例

以下是一个简单的示例，展示了yield关键字的性能影响：

// 使用yield return
public IEnumerable<int> GetNumbers()
{
    for (int i = 0; i < 1000000; i++)
    {
        yield return i;
    }
}

// 不使用yield return
public List<int> GetNumbers()
{
    List<int> numbers = new List<int>();
    for (int i = 0; i < 1000000; i++)
    {
        numbers.Add(i);
    }
    return numbers;
}

在这个例子中：

GetNumbers()方法使用yield return，每次调用MoveNext()时返回一个值，内存占用较低。
GetNumbers()方法不使用yield return，一次性返回所有值，内存占用较高。

总结

yield关键字在处理大量数据或需要延迟执行的场景中可以提高性能和内存效率。
对于非常小的数据集，直接返回集合可能更高效，避免不必要的迭代器开销。
通过基准测试和分析工具评估yield关键字的性能影响，确保合理使用。

通过以上方法和注意事项，可以充分利用yield关键字的优点，同时避免潜在的性能问题。

剖析 yield 关键字如何让程序等待异步操作完成继续执行下一步的原理

Resources.LoadAsync<T>(resourcePath) 是 Unity 中用于异步加载资源的方法。它返回一个 ResourceRequest 对象，该对象表示一个异步操作。通过 yield return request; 语句，你可以使协程（Coroutine）等待异步操作完成，同时不阻塞主线程。下面是这个过程的底层原理：

1. 异步操作初始化

当你调用 Resources.LoadAsync<T>(resourcePath) 时，Unity 会初始化一个异步操作来加载指定路径的资源。这个操作在后台线程上执行，以避免阻塞主线程。

2. 创建 `ResourceRequest` 对象

Unity 创建一个 ResourceRequest 对象来表示这个异步操作。ResourceRequest 包含有关异步操作的信息，如操作的状态、进度和结果。

3. 协程等待异步操作

在你的协程中，通过 yield return request; 语句，你告诉 Unity 使协程进入等待状态，直到异步操作完成。这允许主线程继续执行其他任务，而不是被阻塞。

4. 异步操作完成

当异步操作完成时（即资源加载完成），Unity 会更新 ResourceRequest 对象的状态，并将其标记为完成。

5. 协程恢复执行

一旦异步操作完成，Unity 会恢复协程的执行。此时，你可以从 ResourceRequest 对象中获取加载的资源。

6. 获取结果

通过调用 ResourceRequest.asset 属性，你可以获取加载的资源。如果加载的是泛型类型 T，则可以直接使用该资源。

示例代码

以下是一个简单的示例，展示了如何使用 Resources.LoadAsync<T> 和 yield return 来异步加载资源：

using UnityEngine;
using System.Collections;

public class Example : MonoBehaviour
{
    public string resourcePath = "path/to/your/resource";

    private IEnumerator LoadResourceAsync()
    {
        ResourceRequest request = Resources.LoadAsync<GameObject>(resourcePath);
        yield return request; // 协程等待异步操作完成

        if (request.asset != null)
        {
            GameObject loadedObject = request.asset as GameObject;
            Instantiate(loadedObject); // 实例化加载的资源
        }
        else
        {
            Debug.LogError("Failed to load resource: " + resourcePath);
        }
    }

    private void Start()
    {
        StartCoroutine(LoadResourceAsync()); // 启动协程
    }
}

底层实现细节

线程管理：Unity 使用后台线程来执行资源加载操作，以避免阻塞主线程。
任务调度：Unity 的任务调度系统负责管理异步操作的状态和进度。
内存管理：异步加载的资源在加载完成之前不会占用主线程的内存，这有助于优化内存使用。

通过这种方式，Resources.LoadAsync<T> 和 yield return 结合使用，提供了一种高效且简洁的方法来异步加载资源，同时保持游戏的响应性。

yield return request 语句在 Unity 中用于协程（Coroutine）中等待异步操作完成。它的作用是让协程暂停执行，直到指定的异步操作（在这里是 ResourceRequest 对象表示的异步加载操作）完成后再继续执行。下面是这个过程的具体解释：

1. 协程的暂停与恢复

当协程执行到 yield return request; 时，它会暂停执行，并将控制权返回给 Unity 引擎。
Unity 引擎会继续执行其他任务，同时监控 ResourceRequest 对象表示的异步操作的状态。

2. 异步操作的监控

Unity 引擎内部有一个任务调度系统，它会监控所有正在进行的异步操作。
对于 ResourceRequest 对象，Unity 会监控资源加载的进度和状态。

3. 异步操作的完成通知

当 ResourceRequest 对象表示的异步加载操作完成时（即资源成功加载或加载失败），Unity 会更新 ResourceRequest 对象的状态。
Unity 引擎的任务调度系统会检测到这个状态变化，并准备恢复相应的协程。

4. 协程的恢复执行

一旦 ResourceRequest 对象的状态变为完成，Unity 引擎会安排协程恢复执行。
当协程再次被调度执行时，它会从 yield return 语句之后的下一行代码开始执行。

5. 获取异步操作的结果

在协程恢复执行后，你可以通过 ResourceRequest 对象的属性（如 asset）来获取异步操作的结果。
在上面的示例中，GameObject loadedObject = request.asset as GameObject; 这行代码获取了加载的资源对象。

示例代码回顾

private IEnumerator LoadResourceAsync()
{
    ResourceRequest request = Resources.LoadAsync<GameObject>(resourcePath);
    yield return request; // 协程等待异步操作完成

    if (request.asset != null)
    {
        GameObject loadedObject = request.asset as GameObject;
        Instantiate(loadedObject); // 实例化加载的资源
    }
    else
    {
        Debug.LogError("Failed to load resource: " + resourcePath);
    }
}