UniRx入门系列（五）

最新推荐文章于 2024-04-12 09:37:16 发布

Sun.ME

最新推荐文章于 2024-04-12 09:37:16 发布

阅读量2.5k

点赞数 2

原文链接：https://qiita.com/toRisouP/items/c4b9c5701dd6c991b481

版权

UniRx 专栏收录该内容

6 篇文章 17 订阅

订阅专栏

上节回顾

上次我们分析了如何将Unity中的Update转换为UniRx中的Observable来使用；这一节，我们将讲解一下，如何将UniRx中的协程和UniRx相结合。

Coroutine（协程）和UniRx

默认情况下，Unity中提供了一个叫做“协程”的东西。这个功能在C#中利用IEnumerator和Yield关键字在迭代器迭代过程中实现调用。在Unity主线程中实现类似异步处理的功能。（Unity中的协程并不是多线程，其仍然是在主线程上调用的，他和Update一样，且运行时间也大致相同）。那么我们如何既能够使用Unity的协程来描述处理逻辑，同时有可以使用UniRx来灵活的处理异常呢？

从Coroutinue转换成IObservable

我们先介绍一种从协程转换为IObservable的方法；如果你把协程转换为流，那么你就可以将协程处理结果和UniRx的操作符连接起来。另外，在创建一个复杂行为流的时候，采用协程实现并转化为流的方式，有时，比仅仅使用UniRx操作链构建流要简单的多。

等待携程结束时将其转化为流

使用Observable.FromCoroutine()方法
返回值 IObservable
参数一：Func coroutine
参数二：bool publishEveryYield=false

利用Observable.FromCoroutine()方法，我们可以在协程结束时，将其流化处理。当你需要在协程结束时发出通知，可以使用如下：

public class TestUniRX : MonoBehaviour
{
    void Start()
    {
        Observable.FromCoroutine(NantokaCoroutine, publishEveryYield: false)
        .Subscribe(
            onNext: _ =>
            {
                Debug.Log("OnNext");
            },
            onCompleted: () =>
            {
                Debug.Log("OnCompleted");

            }).AddTo(gameObject);
    }
    private IEnumerator NantokaCoroutine()
    {
        Debug.Log("协程开始");
        yield return new WaitForSeconds(3);
        Debug.Log("协程结束");
    }
}

输出如下：

协程开始
协程结束
OnNext
OnCompleted

注意，Observable.FromCoroutine每被Subscribe一次，就会创建并启动一个新的协程。如果，你只启动了一个协程，并想共享这个流的话，那么你就需要进行流的hot转换。另外，通过Observable.FromeCoroutine启动的协程在终止时会被自动Dispose。如果你想在协程上检测流是否被释放了，可以通过向协程中传递参数来检测流是否被Dispose,如下：

Observable.FromCoroutine(token=>NantokaCoroutine(token));

private IEnumerator NantokaCoroutine(CancellationToken tk)
    {
        Debug.Log("协程开始");
        yield return new WaitForSeconds(3);
        Debug.Log("协程结束");
    }

取出 yield return 迭代的结果

使用Observable.FromCoroutineValue()方法
返回值 IObservable
参数一：Func coroutine
参数二：bool nullAsNextUpdate=true

我们都知道。Unity中的协程的返回值只能是IEnumerator；在协程中，我们不能向使用普通方法那样，将携程的迭代结果赋予一个变量。现在UniRx赋予我们这个能力，我们可以把每次yield的值取出来作为数据流。因为Unity协程中的yield return 每次调用都会停止一帧，可以利用其在某一帧发布值(注意，是指在一帧中执行)：

public class TestUniRX : MonoBehaviour
{
    public List<Vector2> moveList=new List<Vector2>(100);
    void Start()
    {
        Observable.FromCoroutineValue<Vector2>(MovePositionCoroutine)
        .Subscribe(x=>Debug.Log(x));

    
    }

    private IEnumerator MovePositionCoroutine()
    {
        foreach (var item in moveList)
        {
            yield return item;
        }
    }
}

在协程内部发布OnNext

使用Observable.FromCoroutine方法
返回值IObservable
参数一：Func<IObserver,IEnumerator> coroutine,第一个参数为IObserver

此实现将IObserver的实现传递给协程，可以在协程执行过程中发布OnNext.通过使用这个方法，可以在Coroutine和UniRx中进行：内部实现，外部使用。即，内部的实现在协程中异步处理，同时将其作为流对外发布。个人觉得，这也是UniRx提供的最好用的功能之一。另外，记住，此方法的OnCompleted并不会自动发布，所以你需要在协程结束时自己手动发布OnCompleted.

public class TestUniRX : MonoBehaviour
{
    public bool isPaused = false;
    void Start()
    {
        Observable.FromCoroutine<long>(observer => MovePositionCoroutine(observer))
        .Subscribe(x =>
        {
            Debug.Log(x);
        });
    }
    private IEnumerator MovePositionCoroutine(IObserver<long> observer)
    {
        long current = 0;
        float deltaTime = 0;
        while (true)
        {
            if (!isPaused)
            {
                deltaTime+=Time.deltaTime;
                if (deltaTime>=1.0f){
                    var integePart=(int)Mathf.Floor(deltaTime);
                    current+=integePart;
                    deltaTime-=integePart;
                    observer.OnNext(current);
                }
            }
            yield return null;
        }
    }
}

以更轻便、高效的方式执行协程

使用Observable.FromMicroCoroutine/Observable.FromMicroCoroutine
参数一：Func coroutine / Func<IObserver, IEnumerator> coroutine
参数二：FrameCountType frameCountType=FrameCountType.Update协程的执行时机

 public static IObservable<Unit> FromMicroCoroutine(Func<IEnumerator> coroutine, bool publishEveryYield = false, FrameCountType frameCountType = FrameCountType.Update)

 public static IObservable<Unit> FromMicroCoroutine(Func<CancellationToken, IEnumerator> coroutine, bool publishEveryYield = false, FrameCountType frameCountType = FrameCountType.Update)

 public static IObservable<T> FromMicroCoroutine<T>(Func<IObserver<T>, IEnumerator> coroutine, FrameCountType frameCountType = FrameCountType.Update)

Observable.FromMicroCoroutine和Observable.FromMicroCoroutine 的行为几乎和我们之前说过的一致；但是，他们的内部实现却大不相同。虽然在协程内部有yield return 的限制，但是，与Unity标准的协程相比，UniRx提供的MicroCoroutine的启动和运行是非常快速的。它在UniRx中被称之为微协程。以更低的成本启动并运行协程，而不是使用Unity标准的StartCoroutine.

 void Start()
    {
        Observable.FromMicroCoroutine<long>(observer => CountCoroutine(observer))
        .Subscribe(x => Debug.Log(x))
        .AddTo(gameObject);
    }
    IEnumerator CountCoroutine(IObserver<long> observer)
    {
        long number = 0;
        while (true)
        {
            number++;
            observer.OnNext(number);
            yield return null;
        }
    }

将协程转化为IObservable总结

使用UniRx提供的方法将协程转化为IObservable
使用Observable.FromCoroutine启动并执行的协程会被委托给MainThreadDispatcher管理，因此不要忘记手动释放
使用Observable.FromCoroutine会在Subscribe时生成并启动新的协同程序，因此如果你想共享一个协程并进行多次Subscribe时，需要进行hot变换。

从IObservable转换成协程

我们将介绍如何将UniRx流转换成协程流。利用流转化成协程的这个技巧，可以实现诸如在协程上等待流执行结果后继续处理这样的方法。类似于C# 中 Task 的 await .

将流转换为协程

使用 ObservableYieldInstruction ToYieldInstruction(IObservable observable)方法
参数一： CancellationToken cancel 处理进程中断（可选）
参数二： bool throwOnError 发生错误时，是否抛出异常

通过使用ToYieldInstruction,你可以在协程中执行等待。

 void Start()
    {
        StartCoroutine(WaitCoroutine());
    }
    IEnumerator WaitCoroutine()
    {
        Debug.Log("等待一秒钟");
        yield return Observable.Timer(TimeSpan.FromSeconds(1)).ToYieldInstruction();
        Debug.Log("按下键盘上的任意键");
        yield return this.UpdateAsObservable()
        .FirstOrDefault(_ => Input.anyKeyDown)
        .ToYieldInstruction();

        Debug.Log("好了，按下成功");
    }

ToYieldInstruction收到OnCompleted时会终止yield return.因此，如果你不自己手动发布OnCompleted，那么流就永远不会被终止，这是非常危险的。此外，如果你要使用流发出OnNext信息，可以将ToYieldInstruction的返回值存储在ObservableYieldInstruction变量中。

 void Start()
    {
        StartCoroutine(WaitCoroutine());
    }
    IEnumerator DetectCoroutine()
    {
        Debug.Log("协程开始");
        var o = this.OnCollisionEnterAsObservable()
        .FirstOrDefault()
        .Select(x => x.gameObject)
        .Timeout(TimeSpan.FromSeconds(3))
        .ToYieldInstruction(throwOnError: false);

        yield return o;
        if (o.HasError || !o.HasResult)
        {
            Debug.Log("没有和任何对象发生碰撞");
        }
        else
        {
            var hitObj = o.Result;
            Debug.Log("和" + hitObj.name + "发生碰撞");
        }
    }

从IObservable转换成协程总结

使用ToYieldInstruction或者StartAsCoroutine将流转换为协程
可以在协程执行过程中执行等待并发布特定的事件行为。

应用实例

串联协程

 void Start()
    {
        Observable.FromCoroutine(CoroutineA)
        .SelectMany(CoroutineB)
        .Subscribe(_=>Debug.Log("CoroutineA 和CoroutineB 执行完成"));
    }
    IEnumerator CoroutineA()
    {
        Debug.Log("CoroutineA 开始");
        yield return new WaitForSeconds(3);
        Debug.Log("CoroutineB 完成");
    }
    IEnumerator  CoroutineB()
    {
        Debug.Log("CoroutineB 开始");
        yield return new WaitForSeconds(1);
        Debug.Log("CoroutineB 完成");
    }

同时启动多个协程，并等待执行结果

同时启动CoroutineA和CoroutineB,全部结束之后再汇总处理

void Start()
    {
        Observable.WhenAll(
            Observable.FromCoroutine<string>(o => CoroutineA(o)),
            Observable.FromCoroutine<string>(o => CoroutineB(o))
        ).Subscribe(xs =>
        {
            foreach (var item in xs)
            {
                Debug.Log("result:" + item);
            }
        });
    }
    IEnumerator CoroutineA(IObserver<string> observer)
    {
        Debug.Log("CoroutineA 开始");
        yield return new WaitForSeconds(3);
        observer.OnNext("协程A 执行完成");
        Debug.Log("A 3秒等待结束");
        observer.OnCompleted();
    }
    IEnumerator CoroutineB(IObserver<string> observer)
    {
        Debug.Log("CoroutineB 开始");
        yield return new WaitForSeconds(1);
        observer.OnNext("协程B 执行完成");
        Debug.Log("B 1秒等待结束");
        observer.OnCompleted();
    }

执行结果输出如下：

CoroutineB 开始
CoroutineA 开始
B 1秒等待结束
A 3秒等待结束
result:协程A 执行完成
result:协程B 执行完成

将耗时的处理转移到另外一个线程上执行，并在协程上处理执行结果

利用Observable.Start()处理逻辑移到其它线程执行，将返回结果转回到协程中处理

void Start()
    {
       StartCoroutine(GetEnemyDataFromServerCoroutine());
    }
    private IEnumerator GetEnemyDataFromServerCoroutine()
    {
        var www=new WWW("http://api.hogehoge.com/resouces/enemey.xml");
        yield return www;
        if (!string.IsNullOrEmpty(www.error)){
            Debug.Log(www.error);
        }
        var xmlText=www.text;
        var o=Observable.Start(()=>ParseXML(xmlText)).ToYieldInstruction();

        yield return o;
        if (o.HasError){
            Debug.Log(o.Error);
            yield break;
        }
        var result=o.Result;

        Debug.Log(result);
    }

    Dictionary<string,EnemyParameter> ParseXML(string xml){
        return new Dictionary<string, EnemyParameter>();
    }
    struct EnemyParameter{
        public string Name { get; set; }
        public string Helth { get; set; }
        public string Power { get; set; }
    }

上面的实现方式虽然没有下面的实现方式简洁，但是它详细解释了整个执行过程，以下是，上面的缩写：

  ObservableWWW.Get("http://api.hogehoge.com/resouces/enemey.xml")
        .SelectMany(x => Observable.Start(() => ParseXML(x)))
        .ObserveOnMainThread()
        .Subscribe(onNext: result =>
        {
            /*对执行结果进行处理 */
        },
        onError: ex => Debug.LogError(ex));