2.6 协程 (Coroutine)

文档摘要

2.6 协程 (Coroutine) 二、C# 脚本编程 2.6 协程 (Coroutine) 在 Unity3D 的世界中，C# 脚本扮演着至关重要的角色，它赋予了游戏逻辑和行为的生命力。当我们谈论到游戏开发中的异步操作、延迟执行、动画序列控制等需求时，协程 (Coroutine) 便成为了一个不可或缺的强大工具。本章节将深入探讨 Unity3D 中协程的概念、原理、使用方法以及高级技巧，并通过丰富的代码实践和图文结合的方式，帮助你全面掌握这一核心技术。 2.6.1 协程的概念与优势什么是协程？简单来说，协程是一种特殊的函数，它允许你在执行过程中暂停（yield）并在稍后的某一时刻恢复执行。与传统函数一次性执行完毕不同，协程可以在多个帧之间分段执行，而不会阻塞主线程。

2.6 协程 (Coroutine)

二、C# 脚本编程

2.6 协程 (Coroutine)

在 Unity3D 的世界中，C# 脚本扮演着至关重要的角色，它赋予了游戏逻辑和行为的生命力。当我们谈论到游戏开发中的异步操作、延迟执行、动画序列控制等需求时，协程 (Coroutine) 便成为了一个不可或缺的强大工具。本章节将深入探讨 Unity3D 中协程的概念、原理、使用方法以及高级技巧，并通过丰富的代码实践和图文结合的方式，帮助你全面掌握这一核心技术。

2.6.1 协程的概念与优势

什么是协程？

简单来说，协程是一种特殊的函数，它允许你在执行过程中暂停（yield）并在稍后的某一时刻恢复执行。与传统函数一次性执行完毕不同，协程可以在多个帧之间分段执行，而不会阻塞主线程。可以将协程视为轻量级的线程，但它们运行在 Unity 的主线程之上，避免了多线程编程中复杂的同步问题。

协程与线程的区别：

线程 (Thread)：操作系统级别的概念，真正的并行执行，需要考虑线程同步、资源竞争等问题。
协程 (Coroutine)：程序级别的概念，伪并发，本质上仍然是单线程执行，通过 yield 语句让出 CPU 时间片，实现非阻塞的异步效果。

在 Unity 中，所有的游戏逻辑、渲染、输入处理等都发生在主线程中。如果某些操作（例如：网络请求、资源加载、复杂计算、动画播放）耗时较长，直接在主线程中执行会导致游戏卡顿，影响用户体验。协程的出现正是为了解决这类问题，它允许我们将耗时操作分解成多个小步骤，在帧与帧之间执行，从而保持游戏的流畅运行。

协程的优势：

非阻塞性 (Non-blocking)： 协程的暂停和恢复不会阻塞主线程，游戏可以继续响应用户输入和渲染画面，保证流畅性。
异步操作 (Asynchronous Operations)： 方便地实现延迟执行、动画序列、异步任务等，使代码结构更清晰，逻辑更易于管理。
简化代码 (Simplified Code)： 相较于传统的回调函数或状态机，协程可以用更直观、更线性的方式编写异步代码，提高开发效率和代码可读性。
帧率独立性 (Frame-rate Independence)： 可以基于时间而不是帧数来控制协程的执行，确保在不同帧率下行为的一致性。

2.6.2 协程的基本语法与用法

在 C# 脚本中创建和使用协程，需要遵循以下基本语法：

返回类型：IEnumerator

协程函数必须返回 System.Collections.IEnumerator 接口类型。这是协程的标志，Unity 引擎会识别并特殊处理返回 IEnumerator 的函数。
yield return 语句

yield return 是协程的核心关键字，它用于暂停协程的执行，并将控制权返回给 Unity 引擎。yield return 后面可以跟随不同的对象，用于指定协程暂停的时间或条件。
启动协程：StartCoroutine()

使用 MonoBehaviour 类提供的 StartCoroutine() 方法来启动一个协程。StartCoroutine() 接受一个 IEnumerator 对象作为参数，通常是协程函数的调用。
停止协程：StopCoroutine() 和 StopAllCoroutines()

可以使用 StopCoroutine() 方法停止指定的协程，或使用 StopAllCoroutines() 方法停止当前 MonoBehaviour 上所有正在运行的协程。

基本代码示例：


using System.Collections;
using UnityEngine;
public class CoroutineExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(MyCoroutine()); // 启动协程
    }
    IEnumerator MyCoroutine()
    {
        Debug.Log("协程开始执行");
        yield return new WaitForSeconds(2f); // 暂停 2 秒
        Debug.Log("暂停 2 秒后继续执行");
        yield return null; // 等待下一帧
        Debug.Log("下一帧继续执行");
        Debug.Log("协程执行结束");
    }
}

代码详解：

MyCoroutine() 函数被声明为 IEnumerator 返回类型，表示它是一个协程函数。
yield return new WaitForSeconds(2f); 语句使协程暂停执行 2 秒。在这 2 秒内，Unity 引擎会继续执行其他游戏逻辑，不会卡顿。2 秒后，协程会从 yield return 语句的下一行代码继续执行。
yield return null; 语句使协程暂停执行到下一帧。在下一帧开始时，协程会继续执行。
StartCoroutine(MyCoroutine()); 在 Start() 函数中启动 MyCoroutine() 协程。

mermaid graph TD 图示协程执行流程：

2.6.3 `yield return` 的不同类型

yield return 语句后面可以跟随不同的对象，控制协程暂停的行为。Unity 提供了多种预定义的 yield instruction 类，常用的包括：

yield return null:

暂停协程执行到下一帧的开始。
常用于在每一帧中执行一些操作，例如动画的帧更新、平滑移动等。

代码示例：


IEnumerator MoveObjectSmoothly(Transform targetTransform, Vector3 targetPosition, float speed)
{
    while (Vector3.Distance(targetTransform.position, targetPosition) > 0.01f)
    {
        targetTransform.position = Vector3.MoveTowards(targetTransform.position, targetPosition, speed * Time.deltaTime);
        yield return null; // 每帧更新位置
    }
    Debug.Log("物体移动完成");
}

yield return new WaitForSeconds(float seconds):
- 暂停协程执行指定的时间（秒）。
- 常用于延迟执行某些操作，例如延迟生成敌人、延迟显示提示信息等。
代码示例：
```
IEnumerator ShowMessageDelayed(string message, float delay)
{
    yield return new WaitForSeconds(delay);
    Debug.Log("延迟 " + delay + " 秒后显示消息：" + message);
}
```
yield return new WaitForEndOfFrame():
- 暂停协程执行到当前帧的渲染完成之后，但在屏幕显示之前。
- 常用于在所有渲染操作完成后执行一些操作，例如后期处理效果、屏幕截图等。
代码示例：
```
IEnumerator TakeScreenshotAfterRender()
{
    yield return new WaitForEndOfFrame();
    ScreenCapture.CaptureScreenshot("screenshot.png");
    Debug.Log("截图已保存");
}
```
yield return new WaitForFixedUpdate():
- 暂停协程执行到下一个物理引擎更新 (FixedUpdate) 之前。
- 常用于在物理引擎更新之间执行一些操作，例如同步物理模拟和动画、处理物理相关的延迟事件等。
代码示例：
```
IEnumerator ApplyForceAfterFixedUpdate(Rigidbody rb, Vector3 force)
{
    yield return new WaitForFixedUpdate();
    rb.AddForce(force, ForceMode.Impulse);
    Debug.Log("在 FixedUpdate 后施加力");
}
```

yield return StartCoroutine(IEnumerator routine):

启动另一个协程并等待其执行完成。
用于协程的串行执行，一个协程完成后再执行下一个协程。

代码示例：


IEnumerator SequenceCoroutines()
{
    Debug.Log("协程 1 开始");
    yield return StartCoroutine(CoroutineOne()); // 等待 CoroutineOne 执行完成
    Debug.Log("协程 1 执行完成，协程 2 开始");
    yield return StartCoroutine(CoroutineTwo()); // 等待 CoroutineTwo 执行完成
    Debug.Log("协程 2 执行完成，序列结束");
}
IEnumerator CoroutineOne()
{
    Debug.Log("CoroutineOne 开始");
    yield return new WaitForSeconds(1f);
    Debug.Log("CoroutineOne 结束");
}
IEnumerator CoroutineTwo()
{
    Debug.Log("CoroutineTwo 开始");
    yield return new WaitForSeconds(1.5f);
    Debug.Log("CoroutineTwo 结束");
}

yield return new WaitUntil(Func<bool> predicate):

暂停协程执行，直到指定的条件 (predicate) 为真。
常用于等待某个事件发生或某个状态改变。

代码示例：


bool isTargetReached = false;
IEnumerator WaitForTargetReach()
{
    Debug.Log("等待目标到达...");
    yield return new WaitUntil(() => isTargetReached); // 等待 isTargetReached 为 true
    Debug.Log("目标已到达，继续执行");
}
void Update()
{
    // ... 游戏逻辑，当目标到达时设置 isTargetReached = true;
    if (Vector3.Distance(transform.position, targetPosition) < 0.1f)
    {
        isTargetReached = true;
    }
}

yield return new WaitWhile(Func<bool> predicate):

暂停协程执行，只要指定的条件 (predicate) 为真就一直等待，直到条件变为假。
常用于等待某个状态结束。

代码示例：


bool isProcessing = true;
IEnumerator WaitForProcessingComplete()
{
    Debug.Log("等待处理完成...");
    yield return new WaitWhile(() => isProcessing); // 等待 isProcessing 为 false
    Debug.Log("处理已完成，继续执行");
}
void ProcessDataAsync()
{
    // ... 异步处理数据
    StartCoroutine(WaitForProcessingComplete());
    // ... 数据处理开始
    // ... 数据处理完成后设置 isProcessing = false;
    isProcessing = false;
}

2.6.4 协程的进阶应用

1. 协程的停止与取消

StopCoroutine(IEnumerator routine): 停止指定的协程。需要传入 StartCoroutine() 返回的 Coroutine 对象或者协程函数名（字符串）。
StopAllCoroutines(): 停止当前 MonoBehaviour 上所有正在运行的协程。
手动取消协程: 可以在协程内部使用 return 语句提前结束协程的执行。

代码示例：停止协程


Coroutine runningCoroutine;
void Start()
{
    runningCoroutine = StartCoroutine(LongRunningTask());
}
void Update()
{
    if (Input.GetKeyDown(KeyCode.Space))
    {
        StopCoroutine(runningCoroutine); // 停止指定的协程
        Debug.Log("协程已停止");
    }
}
IEnumerator LongRunningTask()
{
    int count = 0;
    while (true)
    {
        Debug.Log("任务执行中... count: " + count);
        count++;
        yield return new WaitForSeconds(0.5f);
        if (count > 100) // 假设某种条件满足时手动结束协程
        {
            Debug.Log("任务完成，手动结束协程");
            yield break; // 手动结束协程，等同于 return;
        }
    }
}

2. 协程的参数传递

协程函数可以像普通函数一样接受参数，方便在启动协程时传递数据。

代码示例：带参数的协程


void Start()
{
    StartCoroutine(FadeOut(GetComponent<Renderer>().material, 1f)); // 启动带参数的协程
}
IEnumerator FadeOut(Material material, float duration)
{
    Color originalColor = material.color;
    float timer = 0f;
    while (timer < duration)
    {
        timer += Time.deltaTime;
        float alpha = Mathf.Lerp(1f, 0f, timer / duration);
        material.color = new Color(originalColor.r, originalColor.g, originalColor.b, alpha);
        yield return null;
    }
    Debug.Log("材质淡出完成");
}

3. 协程的错误处理

虽然协程本身没有专门的错误处理机制，但可以使用 try-catch 块来捕获协程内部的异常。

代码示例：协程中的错误处理


IEnumerator RiskyCoroutine()
{
    try
    {
        Debug.Log("协程开始执行，可能发生错误");
        int result = 10 / 0; // 故意制造除零错误
        Debug.Log("计算结果: " + result); // 这行代码不会执行
    }
    catch (System.Exception e)
    {
        Debug.LogError("协程执行过程中发生错误: " + e.Message);
    }
    finally
    {
        Debug.Log("协程执行结束 (无论是否发生错误)");
    }
    yield return null;
}

4. 协程的嵌套与链式调用

可以使用 yield return StartCoroutine() 来实现协程的嵌套和链式调用，构建复杂的异步流程。

代码示例：协程的链式调用 (已在 2.6.3 中 yield return StartCoroutine 示例展示)

2.6.5 协程的性能考量

虽然协程非常方便，但过度或不当使用也会对性能产生影响。需要注意以下几点：

避免在 Update() 中频繁启动协程: StartCoroutine() 本身有一定的开销，如果每帧都启动新的协程，会造成不必要的性能损耗。通常在 Start() 或事件触发时启动协程，避免在 Update() 中频繁调用。
合理选择 yield return 类型: 不同的 yield return 类型性能开销不同。yield return null 开销最小，WaitForSeconds 开销相对较大，尤其当 seconds 值很小时。根据实际需求选择合适的 yield return 类型。
避免创建过多的协程: 虽然协程是轻量级的，但过多的协程同时运行也会增加 CPU 负担。合理规划协程的使用，避免不必要的协程。
及时停止不再需要的协程: 使用 StopCoroutine() 或 StopAllCoroutines() 及时停止不再需要的协程，释放资源。
对象池技术: 对于频繁创建和销毁的协程，可以考虑使用对象池技术来复用协程对象，减少垃圾回收的压力。 (高级技巧，通常情况下不必过于关注)

2.6.6 协程的应用场景

协程在游戏开发中有着广泛的应用，以下列举一些常见的场景：

动画序列控制: 控制动画的播放顺序、延迟播放、循环播放等。例如，角色技能释放的动画序列、UI 元素的淡入淡出动画等。
延迟执行与定时任务: 延迟一段时间后执行某些操作，例如延迟生成敌人、定时刷新游戏数据、定时触发事件等。
异步资源加载: 在后台异步加载资源，例如场景加载、模型加载、贴图加载等，避免加载过程中游戏卡顿。 (虽然 Unity 提供了更现代的 AsyncOperation 和 Addressables 系统，但协程仍然可以用于简单的异步加载场景)
UI 动画与过渡效果: 实现 UI 元素的平滑动画效果，例如界面切换的淡入淡出、UI 元素的移动、缩放等。
游戏逻辑与AI: 实现一些基于时间的逻辑，例如 AI 角色的巡逻行为、攻击间隔、状态切换等。
特殊效果与视觉特效: 控制粒子特效的播放时长、控制灯光颜色的变化、实现屏幕震动效果等。
网络请求与数据处理: 发起网络请求，并在请求完成后处理返回的数据。 (现代 Unity 开发中，更推荐使用 UnityWebRequest 和 async/await 异步编程模型，但协程仍然可以用于简单的网络请求)

2.6.7 总结

协程是 Unity3D 中 C# 脚本编程的重要组成部分，它提供了一种简洁、高效的方式来处理异步操作、延迟执行和时间相关的游戏逻辑。通过 yield return 语句，我们可以轻松地暂停和恢复协程的执行，实现非阻塞的异步效果，保证游戏的流畅运行。

掌握协程的基本语法、yield return 的不同类型以及进阶应用技巧，将使你能够更加灵活地控制游戏的行为，构建更复杂、更丰富的游戏体验。在实际开发中，根据不同的需求选择合适的 yield return 类型，并注意协程的性能考量，才能充分发挥协程的优势，提升游戏的性能和用户体验。

希望本章节的详细介绍和代码实践能够帮助你深入理解和掌握 Unity3D 中的协程技术，并在你的游戏开发项目中灵活运用。

2.6 协程 (Coroutine)

文档摘要

2.6 协程 (Coroutine)

二、C# 脚本编程

2.6 协程 (Coroutine)

2.6.1 协程的概念与优势

2.6.2 协程的基本语法与用法

2.6.3 yield return 的不同类型

2.6.4 协程的进阶应用

2.6.5 协程的性能考量

2.6.6 协程的应用场景

2.6.7 总结

2.6.3 `yield return` 的不同类型