Unity中协程的异常处理

Question

我创建了一个脚本来更改它所附加的 GameObject 的透明度，并且我在需要取消的褪色协程中进行透明度更改（并且每次我们使用新值调用 ChangeTransparency() 时都会取消）。我设法让它按照我想要的方式工作，但我想处理充斥我控制台的OperationCanceledException。我知道您不能将 yield return 语句包装在 try-catch 块内。

在 Unity 协程中处理异常的正确方法是什么？

这是我的脚本：

using System;
using System.Collections;
using System.Threading;
using UnityEngine;

public class Seethrough : MonoBehaviour
{
    private bool isTransparent = false;
    private Renderer componentRenderer;
    private CancellationTokenSource cts;
    private const string materialTransparencyProperty = "_Fade";


    private void Start()
    {
        cts = new CancellationTokenSource();

        componentRenderer = GetComponent<Renderer>();
    }

    public void ChangeTransparency(bool transparent)
    {
        //Avoid to set the same transparency twice
        if (this.isTransparent == transparent) return;

        //Set the new configuration
        this.isTransparent = transparent;

        cts?.Cancel();
        cts = new CancellationTokenSource();

        if (transparent)
        {
            StartCoroutine(FadeTransparency(0.4f, 0.6f, cts.Token));
        }
        else
        {
            StartCoroutine(FadeTransparency(1f, 0.5f, cts.Token));
        }
    }

    private IEnumerator FadeTransparency(float targetValue, float duration, CancellationToken token)
    {
        Material[] materials = componentRenderer.materials;
        foreach (Material material in materials)
        {
            float startValue = material.GetFloat(materialTransparencyProperty);
            float time = 0;

            while (time < duration)
            {
                token.ThrowIfCancellationRequested();  // I would like to handle this exception somehow while still canceling the coroutine

                material.SetFloat(materialTransparencyProperty, Mathf.Lerp(startValue, targetValue, time / duration));
                time += Time.deltaTime;
                yield return null;
            }

            material.SetFloat(materialTransparencyProperty, targetValue);
        }
    }
}

我的临时解决方案是检查令牌的取消标志并跳出 while 循环。虽然它解决了当前的问题，但我仍然需要一种方法来处理这些在 Unity 中的异步方法（协程）中引发的异常。

Answer 1

---

这个答案是“don’t do that...try this instead”的一个例子。

---

编辑：如果您不想使用Tasks 并且对协程不太确定，为什么不在每次帧更新中使用简单的基于时间的插值函数。这是协程尝试做的更简洁的版本。

---

Unity 中的协程提供了一种简单的方法来对一系列帧执行冗长的操作，但它们并非没有问题。其中之一是关于他们在整个 C# 社区中明显奇怪地使用 IEnumerator 的激烈辩论（搜索此站点）。但可惜我跑题了。

协同程序的替代方案？

为什么不直接使用async/await？自 Unity 2018.1 以来，Unity 已完全支持 .NET 4.5+ 以及 基于任务的异步模式 (TAP )。一旦你这样做了，你会发现事情变得更容易了，你可以向更广泛的代码示例敞开心扉，并避开讨厌的 IEnumerator 辩论。

MSDN：

在 Unity 中，异步编程通常使用协程完成。但是，从 C# 5 开始，在 .NET 开发中首选的异步编程方法一直是基于任务的异步模式 (TAP)，它在 System.Threading.Task 中使用 async 和 await 关键字。总之，在异步函数中，您可以等待任务完成，而不会阻止应用程序的其余部分更新...More...

示例由 MSDN 提供：

// .NET 4.x async-await
using UnityEngine;
using System.Threading.Tasks;
public class AsyncAwaitExample : MonoBehaviour
{
    private async void Start()
    {
        Debug.Log("Wait.");
        await WaitOneSecondAsync();
        DoMoreStuff(); // Will not execute until WaitOneSecond has completed
    }
    private async Task WaitOneSecondAsync()
    {
        await Task.Delay(TimeSpan.FromSeconds(1));
        Debug.Log("Finished waiting.");
    }
}

异常处理

在 Unity 中取消协程操作

在 Unity 协程中处理异常的正确方法是什么？

所以这是协程的第一个问题。

答案是根本不使用协程（假设您运行的是 Unity 2018.1+）并开始迁移到 async/await。然后可以进行异常处理如：

using UnityEngine;
using System.Threading.Tasks;
public class AsyncAwaitExample : MonoBehaviour
{
    CancellationTokenSource cts;

    private async void Start()
    {
        cts = new CancellationTokenSource ();
        Debug.Log("Wait.");

        try
        {
            await DoSomethingRisky(cts.Token);
        }
        catch (ApplicationException ex)
        {
            Debug.LogError("Terribly sorry but something bad happened");
        }

        DoMoreStuff(); // Will not execute until DoSomethingRisky has completed/faulted
    }

    private async Task DoSomethingRisky()
    {
        // ...something risky here

        throw new ApplicationException("Ouch!");
    }
}

现在要处理特定情况，例如任务取消，您将：

public class AsyncAwaitExample : MonoBehaviour
{
    CancellationTokenSource cts;

    private async void Start()
    {
        cts = new CancellationTokenSource ();
        Debug.Log("Wait.");

        try
        {
            await PerformLengthyOperationAsync(cts.Token);
        }
        catch (OperationCanceledException ex) 
        {
            // task was cancelled
        }
        catch (ApplicationException ex)
        {
            Debug.LogError("Terribly sorry but something bad happened");
        }
    }

    private void Update ()
    {
        try
        {
            if (someCondition)
               cts.Cancel();
        }
        catch (OperationCanceledException ex) 
        {
            // Yup I know, I cancelled it above
        }
    }

    private async Task PerformLengthyOperationAsync(CancellationToken token)
    {
        var ok = true;

        do
        {
            token.ThrowIfCancellationRequested ();

            // continue to do something lengthy...
            // ok = still-more-work-to-do?
        }
        while (ok);
    }
}

另见

• Using .NET 4.x in Unity, MSFT
• .NET profile support，团结
• Arnott, A, Recommended patterns for CancellationToken, DevBlogs, Microsoft

Answer 2

other answer 很好，但实际上对于您要解决的用例来说并不是很重要。

您没有任何异步代码，但需要在 Unity 主线程中执行代码，因为它使用 Unity API，并且大部分只能在主线程上使用。

Coroutine 是NOT ASYNC，与多线程或任务无关！

Coroutine 基本上只是一个 IEnumerator，只要它被 StartCorotuine 注册为 Coroutine，然后 Unity 在其上调用 MoveNext（它将执行所有操作，直到下一个 yield return 语句）在 @987654328 之后@ 所以在 Unity 主线程上的一帧（有一些特殊的 yield 语句，如 WaitForFixedUpdate 等，它们在不同的消息堆栈中处理，但仍然存在）。

例如

// Tells Unity to "pause" the routine here, render this frame
// and continue from here in the next frame
yield return null;

或

// Will once a frame check if the provided time in seconds has already exceeded
// if so continues in the next frame, if not checks again in the next frame
yield return new WaitForSeconds(3f);

如果您确实需要以某种方式对例程本身内的取消做出反应，那么您的方法没有什么可说的，除了立即抛出异常，而是只检查 CancellationToken.IsCancellationRequested 并对其做出反应

while (time < duration)
{
    if(token.IsCancellationRequested)
    {
        // Handle the cancelation

        // exits the Coroutine / IEnumerator regardless of how deep it is nested in loops
        // not to confuse with only "break" which would only exit the while loop
        yield break;
    }
            
    ....

---

也回答你的标题。确实，您不能在 try - catch 块内执行 yield return ，正如一般所说的那样，无论如何也没有真正的理由这样做。

如果您确实需要，您可以将不带 yield return 的部分代码封装在 try - catch 块中并在 catch 中进行错误处理，然后您可以再次使用 yield break。

private IEnumerator SomeRoutine()
{
    while(true)
    {
        try
        {
            if(Random.Range(0, 10) == 9) throw new Exception ("Plop!");
        }
        catch(Exception e)
        {
            Debug.LogException(e);
            yield break;
        }

        yield return null;
    }
}