13.UniRx序列（Start、AsObservable、AsSingleUnitObservalbe、AsUnitObservable、ToAsync、ForEachAsync）

Start
AsObservable
AsSingleUnitObservable
AsUnitObservable
ToAsync
ForEachAsync

Start

启动一个异步方法来返回方法的执行结果，创建一个流，将流的方法数据输出到基础流，图解

执行结果

代码示例

public class No13_Mixed3 : MonoBehaviour
{
    void Start()
    {
        var start = Observable.Start(StartMethod);
        start.Subscribe(Next, Error, Complete);
    }

    void StartMethod()
    {
        Debug.LogFormat("StartMethod");
    }

    void Next(Unit unit)
    {
        Debug.LogFormat("Start事件发生了");
    }

    void Error(Exception ex)
    {
        Debug.LogException(ex);
    }

    void Complete()
    {
        Debug.LogFormat("Complete");
    }
}

代码解析

Start一般用于启动一个线程，执行阻塞或者耗时的操作，使用了C#的await关键词来融合

---

AsObservable

将原始数据转换到流，跟之前的From差不多，那个不知道用法的字段，图解

执行结果

代码示例

public class No13_Mixed3 : MonoBehaviour
{
    void Start()
    {
        var asObservable = Observable.Return(100).AsObservable();
        asObservable.Subscribe(Next, Error, Complete);
    }

    void StartMethod()
    {
        Debug.LogFormat("StartMethod");
    }

    void Next(int val)
    {
        Debug.LogFormat("asObservable异步事件发生了，数值:{0}", val);
    }

    void Error(Exception ex)
    {
        Debug.LogException(ex);
    }

    void Complete()
    {
        Debug.LogFormat("Complete");
    }
}

代码解析

AsObservable，将一个非Observable数据转换到Observable数据，转换过来的数据会变成异步数据，但不会影响基础流的数据包装类型；Observable大多数方法都是异步方法，非MicroCoroutine的异步就是async/await的异步方式，非常优雅。

---

AsSingleUnitObservable

和AsObservalbe差不多，会影响流的包装类型，如果是多个流则转换之后变成一个流，按照就近原则来处理流，取最后或最近的一个流作为结果输出

执行结果
代码示例
代码解析

AsSingleUnitObservable会将转换过来的流强行转换到Unit的包装类型，并且只取一个

---

AsUnitObservable

和AsSingleUnitObservable差不多，但不会影响流的结果输出，也不会按照流的就近原则来处理流

执行结果
代码示例
代码解析

---

ToAsync

ToAsync和Start功能类型，开启一个新的线程处理耗时工作，可以转换流到函数指针，图解

执行结果

代码示例

public class No13_Mixed3 : MonoBehaviour
{
    void Start()
    {
        var toAsync = Observable.ToAsync(ToAsyncMethod);
        toAsync = ToAsyncHandler;
        var invoke = toAsync.Invoke();
        invoke.Subscribe(Next, Error, Complete);
    }

    private IObservable<Unit> ToAsyncHandler()
    {
        Debug.LogFormat("ToAsyncHandler");
        return Observable.ReturnUnit();
    }

    void ToAsyncMethod()
    {
        Debug.LogFormat("ToAsyncMethod");
    }

    void Next(Unit unit)
    {
        Debug.LogFormat("ToAsync -> Invoke事件发生了");
    }

    void Error(Exception ex)
    {
        Debug.LogException(ex);
    }

    void Complete()
    {
        Debug.LogFormat("Complete");
    }
}

代码解析

对于返回这种特殊的函数指针，处理的方式就是赋值以后直接Invoke()，不能直接调用，不能像C++那样直接调用指针地址，在C#里面，直接Invoke；通过反射来实例化一个out类型的指针函数，之前的那个From转换的也应该是这样处理的；*第一步ToAsync，里面需要一个action来回调，这个方法在主线程里面执行，表示开始进行异步操作了，是不是要做什么准备，预处理什么；*当这个方法返回以后，进行了下一步的，函数指针处理阶段，这个方法处理的是异步数据，可以进行阻塞操作，当这个IObservable返回以后，表示阻塞的事件结束；可以进行流的后续操作。

---

ForEachAsync

ForEachAsync通过异步的方式将一个数据列表全部遍历出来，符合就近原则，会影响基础流的包装类型

执行结果

代码示例

public class No13_Mixed3 : MonoBehaviour
{
    void Start()
    {
        var range = Observable.Range(1, 3);
        var forEachAsync = range.ForEachAsync(NextForEach);
        forEachAsync.Subscribe(Next, Error, Complete);
    }

    void NextForEach(int val)
    {
        Debug.LogFormat("NextForEach 事件发生了，数据：{0}", val);
    }

    void Next(Unit val)
    {
        Debug.LogFormat("Next 事件发生了");
    }

    void Error(Exception ex)
    {
        Debug.LogException(ex);
    }

    void Complete()
    {
        Debug.LogFormat("Complete");
    }
}

代码解析

是UniRx特有的遍历方式，好处是由于是异步遍历，可能数据遍历的输出顺序不一致；但不会影响最终的输出结果，当我们存在一个数据列表有多个Observable的时候，可以使用ForEachAsync来遍历处理结果。

---