【UniRx】第一季：入门精讲

最新推荐文章于 2024-06-16 21:56:43 发布

林枫依依

最新推荐文章于 2024-06-16 21:56:43 发布

阅读量1.5k

点赞数 1

分类专栏： # UniRx 文章标签： unity3d

本文链接：https://blog.csdn.net/qq_41603955/article/details/119764028

版权

UniRx 专栏收录该内容

2 篇文章 4 订阅

订阅专栏

前提：本人用的Unity2019.3.0f3，从AssetStore上直接下的UniRx 7.1.0;（摘自凉鞋）

【第一章节】

一、UniRx简介

UniRx 是一个 Unity3D 的编程框架。
专注于解决异步逻辑，使得异步逻辑的实现更加简洁优雅。

简洁优雅如何体现?
比如，实现一个”只处理第一次鼠标点击事件”这个功能，使用 UniRx 实现如下：

void Start()
    {
        Observable.EveryUpdate()                      //1.开启Update的事件监听
            .Where(_ => Input.GetMouseButtonDown(0))  //2.每次Update事件被调⽤时，进⾏⼀个⿏标是否抬起的条件判断。
            .First()                                  //3.如果判断通过，则进⾏计数，并且只获取第一次的点击的事件。
            .Subscribe(_ =>                           //4.订阅/处理事件
            {
                Debug.Log("鼠标已点击");
            });
    }

如果使⽤传统的⽅式实现”只处理第⼀次鼠标点击事件“，这个功能，不知道要写多少行代码，还要创建一个成员变量来记录点击次数，或者是否点击过。还要在脚本中创建一个 Update 方法来监听鼠标抬起事件。
如果在 Update 方法中，除了实现鼠标事件监听这个功能之外，还要实现其他的功能。那么Update 里就会充斥着大量的状态判断等逻辑。代码非常不容易阅读。

而 UniRx 提供了一种编程思维，使得平时一些比较难实现的异步逻辑（比如当前这种），使用 UniRx轻松搞定，并且不失代码的可读性。
当然 UniRx 的强大不仅如此。
它还可以：
• 优雅实现 MVP （MVC）架构模式。
• 对 UGUI/Unity API 提供了增强，很多需要写大量代码的 UI 逻辑，使用 UniRx 优雅实现。
• 轻松实现非常复杂的异步任务处理理。
• 等等。
最最重要的是，它可以提高我们的编码效率。还给我们的大脑提供一个强有力的编程模型。
UniRx 非常值得研究学习，就连大名鼎鼎的 uFrame 框架，在 1.6 版本之后使用 UniRx 做了大幅重构，底层使⽤ UniRx 强力驱动。

二、为什么要用 UniRx?

UniRx 就是 Unity Reactive Extensions。是 Unity 版本的 Reactive Extensions。
Reactive Extensions 的擅长的部分是处理时间上异步的逻辑。
游戏很多的系统都是在时间上异步的，所以Unity 开发者要实现的异步（在时间上）任务，是⾮常多的。
这也是为什么 Unity 官⽅提供了 Coroutine （协程）这样的概念。
在游戏中，大部分的逻辑都是在时间上异步的。比如动画的播放、声音的播放、网络请求、资源加载/卸载、Tween、场景过渡等都是在时间上异步的逻辑。甚⾄是游戏循环（Every Update，OnCollisionEnter，etc），传感器数据（Kinect，Leap Motion，VR Input，etc.）都是(时间上)异步的事件。

我们往往在进行以上逻辑实现的时候经常用到大量的回调，最终随着项⽬的扩张导致传说中的”回调地狱”。
相对较好的方法则是使⽤消息/事件的发送，结果导致“消息满天飞”，导致代码非常难以阅读。
使⽤ Coroutine 也是非常不错的，但是 Coroutine 本身的定义，是以⼀个方法的格式定义的，写起来是非常面向过程的。当逻辑稍微复杂一点，就很容易造成 Coroutine 嵌套 Coroutine，代码是非常不容易阅读的（强耦合）。
而 UniRx 的出现刚好解决了这个问题，它介于回调和事件之间。它有事件的概念，只不过他的事件是像水⼀样流过来，而我们要做的则是简单地进行组织、变换、过滤、合并。它也用到了回调，只不过事件组织之后，只有简单一个回调就可以进行事件的处理了。
它的原理和 Coroutine(迭代器模式) 非常类似，但是比 Coroutine 强大得多。
UniRx 将（时间上）异步事件转化为 (响应式的) 事件序列，通过 LINQ 操作可以很简单地组合起来，还支持时间操作。
为什么要用 UniRx 呢？
总结为一句话就是，游戏本身有大量的（时间上）异步逻辑，而 UniRx 恰好擅长处理（时间上）异步逻辑，使⽤ UniRx 可以节省我们的时间，同时让代码更简洁易读。
Rx 只是一套标准，在其他语⾔也有实现，如果在 Unity 中熟悉了这套标准，在其他语言上也是可以很快上⼿的。比如 RxJava、Rx.cpp、SwiftRx 等等。

三、定时功能实现

方法一：一般定时器

using UnityEngine;

public class CommonTimerExample : MonoBehaviour
{
    private float mStartTime;

    void Start()
    {
        mStartTime = Time.time;
    }

    void Update()
    {
        if(Time.time-mStartTime>5)
        {
            Debug.Log("一般定时器");
            mStartTime = float.MaxValue;
        }
    }
}

方法二：Coroutine（协程）定时器

using System;
using System.Collections;
using UnityEngine;

public class CoroutineTimerExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(Timer(5, () =>
         {
             Debug.Log("协程定时器");
         }));
    }

    IEnumerator Timer(float seconds,Action callback)
    {
        yield return new WaitForSeconds(seconds);
        callback();
    }
}

方法三：UniRx定时器

using UnityEngine;
using System;
using UniRx;

public class UniRxTimerExample : MonoBehaviour
{
    void Start()
    {
        Observable.Timer(TimeSpan.FromSeconds(5.0f))
            .Subscribe(_ =>
            {
                Debug.Log("UniRx定时器");
            });
    }
}

比较可知，使用 UniRx很简单，当然以上代码是没有和 MonoBehaviour 进行生命周期绑定的。
要绑定很简单。

void Start()
    {
        Observable.Timer(TimeSpan.FromSeconds(5.0f))
            .Subscribe(_ =>
            {
                Debug.Log("UniRx计时器");
            })
            .AddTo(this);
    }

只要加上一个 AddTo(this) 就可以了了。
这样，当 this(MonoBehaviour) Destroy 的时候，这个延时逻辑也会销毁掉，从⽽避免造成空指针异常。
三行代码，大约 20 秒时间，就搞定了一个实现起来比较麻烦的逻辑。

四、独立的Update

监听鼠标左右键按下：

using UnityEngine;
using UniRx;

public class UpdateExample : MonoBehaviour
{
    enum ButtonState
    { 
        None,
        Clicked,
    }
    
    void Start()
    {
        ButtonState buttonState = ButtonState.None;
        bool buttonClicked = false;

        //监听鼠标左键
        Observable.EveryUpdate()
            .Subscribe(_ =>
            {
                if (Input.GetMouseButtonDown(0))
                {
                    Debug.Log("鼠标左键按下");
                    buttonClicked = true;
                }
            });

        //监听鼠标右键
        Observable.EveryUpdate()
            .Subscribe(_ =>
            {
                if (Input.GetMouseButtonDown(1))
                {
                    Debug.Log("鼠标右键按下");
                    buttonClicked = true;
                }
            });

        //监听鼠标状态
        if (buttonClicked && buttonState == ButtonState.None)
        {
            buttonState = ButtonState.Clicked;
        }
    }
}

虽然在代码长度上跟我们平时写的没有任何改善，但是最起码，这些 Update 逻辑互相之间独⽴了。
状态跳转、延时等等这些经常在 Update 里实现的逻辑，都可以使⽤以上这种方式独⽴。
我们使⽤ UniRx 对代码进行了一点改善，在接触 UniRx 之后，就再也没有使用过MonoBehaviour 提供的 Update 方法了。
不过这种 UniRx 的使⽤还比较初级，本节课所介绍的方式，随着对 UniRx 的深入，也会渐渐淘汰，因为后边有更好的实现方式。

五、AddTo

字⾯意思上理解为添加到。
添加到哪里呢？
其实就是 Unity 的 GameObject 或者 MonoBehaviour。

为什么要添加到 GameObject 或者 MonoBeaviour 呢?
是因为，GameObject 和 MonoBehaviour 可以获取到 OnDestroy 事件。也就是 GameObject 或者MonoBehaviour 的销毁事件。
那么用这个销毁事件干嘛呢？
答案是用来进行与 UniRx 进行销毁事件的绑定，也就是当 GameObject 或者 MonoBehaviour 被销毁时，同样去销毁正在进行的 UniRx 任务。
这就是 AddTo API 的作用。
其实用起来很简单，代码如下:

Observable.Timer(TimeSpan.FromSeconds(1.0f)
.Subscribe()
.AddTo(this); // Or gameObejct

这样，当 this 所在的 GameObject 销毁时，这个 Timer 就会被销毁。

为什么会这样?
本质上， AddTo 是一个静态扩展关键字，他对 IDisposable 进行了扩展。
只要任何实现了 IDisposable 的接口，都可以使用 AddTo API，不管是不是 UniRx 的 API。
当 GameObject 销毁时，就会调用 IDisposable 的 OnDispose 这个方法。
很容易理解。
AddTo 能做什么?
有了 AddTo，在开启 Observable.EveryUpdate 时调用当前脚本的方法，则不会造成引用异常等错
误，它使得 UniRx 的使用更加安全。

六、UniRx的基本语法格式

Observable.XXX().Subscribe() 是非常典型的 UniRx 格式。
只要理解什么意思就可以看懂大部分的 UniRx 的用法了。

首先解决词汇问题:
Observable: 可观察的，形容词，形容后边的词(Timer) 是可观察的，我们可以粗暴地把 Observable 后边的理解成发布者。
Timer: 定时器，名词，被 Observable 描述，所以是发布者，是事件的发送⽅。
Subscribe: 订阅，动词，订阅谁呢？当然是前边的 Timer，这里可以理解成订阅者，也就是事件的接收⽅。
AddTo: 暂不用理解。
连起来则是:可被观察(监听)的.Timer().订阅()
顺下来应该是:订阅可被观察的定时器。
其概念关系很容易理解。
• Timer 是可观察的。
• 可观察的才能被订阅。

Observable.XXX().Subscribe();
可被观察(监听)的 XX，注册。
以上笔者从发布者和订阅者这个角度来进行的介绍，以便大家理解。
但是 UniRx 的侧重点，不是发布者和订阅者这两个概念如何使用，而是事件从发布者到订阅者之间的过程如何处理。
所以两个点不重要，重要的是两点之间的线，也就是事件的传递过程。
这里先不说得太深⼊，在入门之后，会用很大的篇幅去进行讲解。

七、操作符Where

UniRx 的侧重点，不是发布者和订阅者这两个概念如何使用，而是事件从发布者到订阅者之间的过程如何处理。

using UnityEngine;
using UniRx;

public class WhereExample : MonoBehaviour
{
    void Start()
    {
        Observable.EveryUpdate()
            .Where(_ => Input.GetMouseButtonDown(0))
            .Subscribe(_ =>
            {
                Debug.Log("鼠标点击");
            });

    }
}

Where 意思是在哪儿。这里我们理解成一个条件语句。也就是 if 语句。
类似:
if (Input.GetMouseButtonUp(0))
这段代码和之前的一样。
Where 是一个过滤的操作，过滤掉不满足条件的事件。

给大家一个比较容易理解的解释。
1. EveryUpdate 是事件的发布者。他会每帧会发送一个事件过来。
2. Subscribe 是事件的接收者，接收的是 EveryUpdate 发送的事件。
3. Where 则是在事件的发布者和接收者之间的一个过滤操作。会过滤掉不满足条件的事件。
所以，Subscribe 处理的事件，都是满足 Input.GetMouseButtonUp(0) 条件的事件。
看一下这两幅图，就可以理解了。

是圆形的，才可以通过。
事件的本身可以是参数，但是 EveryUpdate 没有参数，所以在 Where 这行代码中不需要接收参数，所以使用 _ 来表示，不用参数。当然 Subscribe 也是用了一个 _ 来接收参数。
在两幅图中，第一幅图，发送的事件的类型是整数类型。第二个不清楚，应该是自定义 class 吧。

八、操作符First

很简单，就是获取第一个通过的事件。

using UnityEngine;
using UniRx;

public class FirstExample : MonoBehaviour
{
    void Start()
    {
        Observable.EveryUpdate()
            .First(_ => Input.GetMouseButtonDown(0))
            .Subscribe(_ =>
            {
                Debug.Log("鼠标点击");
            })
            .AddTo(this);
    }
}

九、UGUI的支持

UniRx 对 UGUI 进行了支持。
比如最常用的按钮点击事件注册。

using UnityEngine;
using UnityEngine.UI;
using UniRx;
public class UIExample : MonoBehaviour
{
    void Start()
    {
        var button = GameObject.Find("Button").GetComponent<Button>();
        button.OnClickAsObservable()
            .Subscribe(_ => Debug.Log("按钮点击"));

        var toggle = GameObject.Find("Toggle").GetComponent<Toggle>();
        toggle.OnValueChangedAsObservable()
            .Where(on=>on)
            .Subscribe(on => Debug.Log(on));
    }
}

还支持 EventSystem 的各种 Trigger 接口的监听。

比如：Image 本身是 Graphic 类型的，Graphic 类，只要实现 IDragHandler 就可以进行拖拽事件的监听。
但是使用 UniRx 就不用那么麻烦。

using UnityEngine;
using UnityEngine.UI;
using UniRx;
using UniRx.Triggers;

public class UIExample : MonoBehaviour
{
    void Start()
    {
        var image = GameObject.Find("Image").GetComponent<Graphic>();
        image.OnBeginDragAsObservable().Subscribe(_ => Debug.Log("开始拖拽"));
        image.OnDragAsObservable().Subscribe(_ => Debug.Log("正在拖拽"));
        image.OnEndDragAsObservable().Subscribe(_ => Debug.Log("结束拖拽"));
    }
}

十、ReactiveProperty

UniRx 中有个一个非常强大的概念，叫做 ReactiveProperty。响应式属性。
强大在哪呢？它可以替代一切变量，给变量创造了很多功能。
假如我们想监听一个值是否发生了改变。
用通常的方法实现可能如下：

using UnityEngine;
using System;

public class ReactivePropertyExample : MonoBehaviour
{
    public Action<int> OnAgeChanged = null;
    private int mAge = 0;
    public int Age
    {
        get { return mAge;}
        set 
        {
            if(mAge!=value)
            {
                mAge = value;
                if(OnAgeChanged!=null)
                {
                    OnAgeChanged(value);
                }
            }
        }
    }

    void Start()
    {
        OnAgeChanged += age =>
          {
              Debug.Log("inner received age changed");
          };
    }
}

public class PersonView
{
    ReactivePropertyExample mReactivePropertyExample;
    void Init()
    {
        mReactivePropertyExample.OnAgeChanged += (age) =>
          {
              Debug.Log(age);
          };
    }
}

这样在类的内部，写一次 OnAgeChanged 是没问题的。但是我想在这个类的外部监听这个值的改变，那就要声明一个委托来搞定了。委托的维护成本比较低，是可以接受的，直到笔者发现了UniRx 的ReactiveProperty。就再也不想用委托来做这种工作了。

UniRx实现：

using UnityEngine;
using UniRx;

public class ReactivePropertyExample : MonoBehaviour
{
    public ReactiveProperty<int> Age = new ReactiveProperty<int>(0);

    void Start()
    {
        Age.Subscribe(age =>
          {
              Debug.Log("inner received age changed");
          });
        Age.Value = 10;
    }
}

public class PresonView
{
    ReactivePropertyExample mReactivePropertyExample;
    void Init()
    {
        mReactivePropertyExample.Age.Subscribe((age) =>
          {
              Debug.Log(age);
          });
    }
}

当任何时候，Age 的值被设置，就会通知所有 Subscribe 的回调函数。
而 Age 可以被 Subscribe 多次的。
并且同样支持 First、Where 等操作符。
这样可以实现一个叫做 MVP 的架构模式。
也就是在 Ctrl 中，进行 Model 和 View 的绑定。
Model 的所有属性都是用 ReactiveProperty，然后在 Ctrl 中进行订阅。
通过 View 更改 Model 的属性值。
形成一个 View->Ctrl->Model->Ctrl->View 这么一个事件响应环。

十一、MVP实现

我们来实现一个简洁的MVP 模式框架。

在上一讲有简单介绍过，UniRx 对 UGUI 进行了增强。UGUI 增强的原理很简单，就是对 UnityEvent 提供了 AsObservable 方法。

public Button mButton;
mButton.onClick.AsObservable().Subscribe(_=>Debug.Log("按钮点击"));

在此基础上，进一步对每个 UGUI 控件进行封装，从而可以像如下方式在 UGUI 中使用 UniRx。

public Toggle mToggle;
public InputField mInput;
public Text mText;
public Slider mSlider;
void Start()
{
    mToggle.OnValueChangedAsObservable().SubscribeToInteractable(mButton);
    mInput.OnValueChangedAsObservable()
        .Where(x=>x!=null)
        .SubscribeToText(mText);
    mSlider.OnValueChangedAsObservable()
        .SubscribeToText(mText,x=>Math.Round(x,2).ToString());
}

在实现MVP模式之前，先看下下面的代码：

public class Enemy
{
    public ReactiveProperty<long> CurrentHp{get;private set;}
    public ReactiveProperty<long> IsDead{get;private set;}
    public Enemy(int initialHp)
    {
        CurrentHp=new ReactiveProperty<long>(initialHp);
        IsDead=CurrentHp.Select(x=> x<=0).ToReactiveProperty();
    }
}

void Start()
{
   mButton.OnClickAsObservable().Subscribe(_=>enemy.CurrentHp.Value-=99);
   enemy.CurrentHp.SubscribeToText(MyText);
   enemy.IsDead.Where(isDead=>isDead)
               .Subscribe(_=>
               {
                  mButton.interactable=false;
               });
}

这段代码理解起来非常简单，Enemy 是一个数据类，我们可以理解成 Model。
而下边的 Start 部分则是 Ctrl 的代码。它将 Hierarchy 中的 UI 控件与 Model 绑定在了一起。当
Model 有改变则通知 UI 更新，当从 UI 接收到点击事件则对 Model 进行值的更改。这就是一个非常简单的 MVP 模式。

你可以⽤ UnityEvent.AsObservable 将 ReactiveProperties，ReactiveCollections 和Observables 都组合起来。所有 UI 组件都提供了 XXXAsObservable在 Unity 里，序列化是一个很重要的功能，如果不可序列化，则在编辑器上就看不到参数。而ReactiveProperty 是泛型的，序列化起来比较麻烦。为了解决这个问题，UniRx 支持了可序列化的ReactiveProperty 类型，比如 Int/LongReactivePropety、Float/DoubleReactiveProperty、
StringReactiveProperty、BoolReactiveProperty,还有更多，请参见 InspectableReactiveProperty.cs。
以上都可以在 Inspector 中编辑。对于自定义的枚举 ReactiveProperty，写一个可检视的
ReactiveProperty[T] 也很容易。
如果你需要 [Multiline] 或者[Range] 添加到 ReactiveProperty 上，你可以使⽤
MultilineReactivePropertyAttribute 和 RangeReactivePropertyAttribute 替换 Multiline 和 Range。
这些 InspectableReactiveProperties 可以在 inspector 面板显示，并且当他们的值发生变化时发出通知，甚至在编辑器里变化也可以。
这个功能是实现在 InspectorDisplayDrawer。你可以通过继承这个类实现你自定义的
ReactiveProperties 在 Inspector 面板的绘制：

public enum Fruit
{
   Apple,Grape
}
[Serializable]
public class FruitReactiveProperty:ReactiveProperty<Fruit>
{
   public FruitReactiveProperty()
   {
   }
   public FruitReactiveProperty(Fruit initialValue):base(initialValue)
   {
   }
}

[UnityEditor.CustomPropertyDrawer(typeof(FruitReactiveProperty))]
[UnityEditor.CustomPropertyDrawer(typeof(YourSpecializedReactiveProperty2))]
//and others...
public class ExtendInspectorDisplayDrawer:InspectorDisplayDrawer
{
}

如果 ReactiveProperty 的值只在 Stream 中更新，你可以使用 ReadOnlyReactiveProperty 让这个属性只读。

MVP 设计模式 Model-View-（Reactive）Presenter Pattern

使用 UniRx 可以很容易地实现 MVP（MVRP）设计模式。
MVP 的结构图如下所示。

为什么应该用 MVP 模式而不是 MVVM 模式？Unity 没有提供 UI 绑定机制，创建一个绑定层过于复杂并且会对性能造成影响（使用反射）。尽管如此，视图还是需要更新。Presenters 层知道 View 组件并且能更新它们。
虽然没有真的绑定，但 Observables 可以通知订阅者，功能上也差不多。这种模式叫做 Reactive
Presenter：

// Presenter for scene(canvas) root.
public class ReactivePresenter : MonoBehaviour
{
    // Presenter is aware of its View (binded in the inspector)
    public Button mButton;
    public Toggle mToggle;
    // State-Change-Events from Model by ReactiveProperty
    Enemy enemy = new Enemy(1000);
void Start()
{
    // Rx supplies user events from Views and Models in a reactive manner
    mButton.OnClickAsObservable().Subscribe(_=>enemy.CurrentHp.Value -=
99);
    mToggle.OnValueChangedAsObservable().SubscribeToInteractable(mButton);
    // Models notify Presenters via Rx,and Presenters update their views
    enemy.CurrentHp.SubscribeToText(MyText);
    enemy.IsDead.Where(isDead => isDead)
      .Subscribe(_=>
      {
          mToggle.interactable = mButton.interactable = false;
      });
}
}

// The Mode. All property notify when their values change
public class Enemy
{
    public ReactiveProperty<long> CurrentHp { get;private set;}
    public ReactiveProperty<bool> IsDead { get;private set;}
    public Enemy(int initialHp)
    {
       // Declarative Property
       CurrentHp = new ReactiveProperty<long>(initialHp);
       IsDead = CurrentHp.Select(x => x <= 10).ToReactiveProperty();
    }
}

在 Unity 中，我们把 Scene 中的 GameObject 当做视图层，这些是在 Unity 的 Hierarchy 中定义的。
展示/控制层在 Unity 初始化时将视图层绑定。
SubscribeToText and SubscribeToInteractable 都是简洁的类似绑定的辅助函数。虽然这些工具很简单，但是非常实用。
在 Unity 中使用开发体验非常平滑，性能也很好，最重要的是让你的代码更简洁。
View -> ReactiveProperty -> Model -> RectiveProperty - View 完全用响应式的方式连接。UniRx 提供了所有的适配方法和类，不过其他的 MVVM (or MV*) 框架也可以使用。UniRx/ReactiveProperty 只是一个简单的⼯工具包。
使用 UniRx 实现的 MVP 模式结构图如下：

十二、操作符Merge

Merge 意思是合并。
合并什么呢？
我们之前学习过，UniRx 的世界里，任何东西都是以事件流的形式存在的。
而在之前我们使用的 Update、Timer 等，全都是开启了一条事件流。
但是到现在为止，老师有说过 UniRx 只能 Subscribe 一条事件流么？
没有。
UniRx 可以开启两个或多个事件流。
并使用 Merge 进行事件流的合并。

比如:

using UnityEngine;
using UniRx;

public class MergeExample : MonoBehaviour
{
    void Start()
    {
        var leftClickEvents = Observable.EveryUpdate().Where(_ => Input.GetMouseButtonDown(0));
        var rightClickEvents = Observable.EveryUpdate().Where(_ => Input.GetMouseButtonDown(1));

        Observable.Merge(leftClickEvents, rightClickEvents)
            .Subscribe(_ =>
            {
                Debug.Log("鼠标点击");
            });
    }
}

以上代码的实现的逻辑是“当鼠标左键或右键点击时都会进行处理“。
也就是说，Merge 操作符将 leftMouseClickStream 和 rightMouseClickStream 合并成了一个事件流。
如下图所示:

十三、实现“某个按钮点击时，使当前页面所有的按钮不可被点击”

我们一般的实现是加上一个事件的遮罩层，或者创建一个 bool 变量来进行标记。
而使用 UniRx 则会简单得多。
代码如下:

using UnityEngine;
using UniRx;
using UnityEngine.UI;
using System;

public class PanelEventLockExample : MonoBehaviour
{
    void Start()
    {
        var btnA = GameObject.Find("ButtonA").GetComponent<Button>();
        var btnB = GameObject.Find("ButtonB").GetComponent<Button>();
        var btnC = GameObject.Find("ButtonC").GetComponent<Button>();

        var aStream = btnA.OnClickAsObservable();
        var bStream = btnB.OnClickAsObservable();
        var cStream = btnC.OnClickAsObservable();

        Observable.Merge(aStream, bStream, cStream)
            .First()
            .Subscribe(_ =>
            {
                Debug.Log("按钮点击");
                Observable.Timer(TimeSpan.FromSeconds(3.0f)).Subscribe(__ =>
                {
                    GameObject.Find("Canvas").SetActive(false);
                });
            });
    }
}

使用 Merge 将三个按钮的事件流合并。并通过 First 只处理第一次点击事件。
这样标题的所说的功能就完成了。

十四、使用 Select 操作符进行功能改进

但是还有一点问题，就是当处理按钮事件的时候要知道是哪个按钮被点击了。
很简单，使用 Select 操作符就好了。
Select 是什么意思呢？
就是选择。
Select 本身是 Linq 的操作符。
一般是传⼊一个索引 i/index 然后根据索引返回具体的值。
对于一个 List，什么叫做 Selecte 呢？
看代码就懂了,如下:

var testNumbers = new List<int>(){ 1,2,3}
var selectedValue = testNumbers[2];

其中 testNumbers[2] 就是一个选择操作。
Select 的操作符会在第二章进行详细解释。
先用下边的图，试着理解一下就好。

这里我们只要了解，使用 Select 操作符后，它返回的是一个值就好了，值的类型根据它返回的值的类型决定，也就是说是一个泛型的。
使用 Select 之后的代码如下:

using UnityEngine;
using UniRx;
using UnityEngine.UI;
using System;

public class PanelEventLockExample : MonoBehaviour
{
    void Start()
    {
        var btnA = GameObject.Find("ButtonA").GetComponent<Button>();
        var btnB = GameObject.Find("ButtonB").GetComponent<Button>();
        var btnC = GameObject.Find("ButtonC").GetComponent<Button>();

        var aStream = btnA.OnClickAsObservable().Select(_ => "A");
        var bStream = btnB.OnClickAsObservable().Select(_ => "B");
        var cStream = btnC.OnClickAsObservable().Select(_ => "C");

        Observable.Merge(aStream, bStream, cStream)
            .First()
            .Subscribe(btnId =>
            {
                Debug.LogFormat("按钮{0}点击",btnId);
                Observable.Timer(TimeSpan.FromSeconds(3.0f)).Subscribe(__ =>
                {
                    GameObject.Find("Canvas").SetActive(false);
                });
            });
    }
}

这样，标题所说的功能，完美实现了。
第一章的内容就结束了。
Merge 属于处理多个流的操作符，除此之外还有更多的类似的，比如 Zip 等等。学习完它们之后可以实现非常复杂的逻辑，比如 Coroutine 的支持，可以实现按顺序执行多个 Coroutine ，也支持等待所有 Coroutine 执行完成这种复杂的操作。

【第二章节】

一、简介

UniRx 之所以叫做 UniRx 是因为它是 Unity 版本的 Reactive Extensions。
是单独对 Unity 做了很多功能上的增强。
• UI 增强
• GameObject/MonoBehaviour 增强以及引擎的事件增强(OnApplicationPause、 UnityEvent)
• Coroutine/Thread 增强
• 网络请求(WWW 等)
• ReactiveProperty、ReactiveCollection、ReactiveDictionary 等。
• ReactiveCommand 命令系统。
• …
学习完以上的内容可以让我们的日常开发事半功倍。

二、UI增强

作为初学者，在日常开发中接触得最多的就是 UGUI 了。而 UGUI 的开发大多需要遵循着一个 MVC的模式。
但是 MVC 模式对很多人来说是一个非常模糊的架构模式。但是本质很简单，想办法把表现和数据分离。也就是 View 和 Model 分离。
用 Unity 实现的方式有非常多种。
而用 UniRx 的 Reactive Property 则是可以完全实现一种 MVC 的变种（MVP），并且是非常明确的。这样在开发的时候就不用再去纠结怎么实现了。
单单这一个概念，就让一个 UGUI 的开发简化了很多
除此之外，还支持了非常多的 UGUI 控件。
所有的 UGUI 控件支持列出如下：

[SerializeField] Button mButton;
[SerializeField] Toggle mToggle;
[SerializeField] Scrollbar mScrollbar;
[SerializeField] ScrollRect mScrollRect;
[SerializeField] Slider mSlider;
[SerializeField] InputField mInputField;
void Start()
{
    mButton.OnClickAsObservable().Subscribe(_ => Debug.Log("On Button
Clicked"));
    mToggle.OnValueChangedAsObservable().Subscribe(on => Debug.Log("Toggle " +
on));
    mScrollbar.OnValueChangedAsObservable().Subscribe(scrollValue =>
Debug.Log("Scrolled " + scrollValue));
    mScrollRect.OnValueChangedAsObservable().Subscribe(scrollValue =>
Debug.Log("Scrolled " + scrollValue);
    mSlider.OnValueChangedAsObservable().Subscribe(sliderValue =>
Debug.Log("Slider Value " + sliderValue));
    mInputField.OnValueChangedAsObservable().Subscribe(inputText =>
Debug.Log("Input Text: " + inputText));
    mInputField.OnEndEditAsObservable().Subscribe(result =>
Debug.Log("Result :" + result));
}

以上就是所有的 Observable 支持。
当然除了 Observable 增强，还支持了 Subscribe 的增强。
比如 SubscribeToText

Text resultText = GetComponent<Text>();
mInputField.OnValueChangedAsObservable().SubscribeToText(resultText);

这段代码实现的功能是，当 mInputField 的输入值改变，则会马上显示在 resultText 上。也就是完成了，mInputField 与 resultText 的绑定。
除此之外还支持，SubscribeToInteractable。基本上这样就够用了。
本节课介绍的就是 UniRx 对 UI 的全部支持。

三、登录注册界面

using UnityEngine;
using UniRx;
using UnityEngine.UI;

public class LoginPanel : MonoBehaviour
{
    Button mLoginBtn; 
    Button mRegisterBtn;
    InputField mUsername;
    InputField mPassword;

    void Start()
    {
        mLoginBtn = transform.Find("Login").GetComponent<Button>();
        mRegisterBtn = transform.Find("Register").GetComponent<Button>();
        mUsername = transform.Find("Username").GetComponent<InputField>();
        mPassword = transform.Find("Password").GetComponent<InputField>();

        mLoginBtn.OnClickAsObservable().Subscribe(_ =>
        {
            Debug.Log("loginBtn clicked");
        }); 
        mUsername.OnEndEditAsObservable().Subscribe(result =>
        {
            //回车键 直接进入下一行
            mPassword.Select();
        });
        mPassword.OnEndEditAsObservable().Subscribe(result =>
        {
            mLoginBtn.onClick.Invoke();
        });

        mRegisterBtn.OnClickAsObservable().Subscribe(_ =>
        {
            LoginRegisterExample.PanelMgr.loginPanel.gameObject.SetActive(false);
            LoginRegisterExample.PanelMgr.registerPanel.gameObject.SetActive(true);
        });
    }
}

using UnityEngine;
using UniRx;
using UnityEngine.UI;

public class RegisterPanel : MonoBehaviour
{
    Button mRegisterBtn;
    Button mBackBtn;
    InputField mUsername;
    InputField mPassword1;
    InputField mPassword2;

    void Start()
    {
        mRegisterBtn = transform.Find("Register").GetComponent<Button>();
        mBackBtn = transform.Find("ReturnLogin").GetComponent<Button>();
        mUsername = transform.Find("Username").GetComponent<InputField>();
        mPassword1 = transform.Find("Password1").GetComponent<InputField>();
        mPassword2 = transform.Find("Password2").GetComponent<InputField>();

        mUsername.OnEndEditAsObservable().Subscribe(result =>
        {
            //回车键 直接进入下一行
            mPassword1.Select();
        });
        mPassword1.OnEndEditAsObservable().Subscribe(result =>
        {
            mPassword2.Select();
        }); 
        mPassword2.OnEndEditAsObservable().Subscribe(result =>
        {
            mRegisterBtn.onClick.Invoke();
        });

        mBackBtn.OnClickAsObservable().Subscribe(_ =>
        {
            LoginRegisterExample.PanelMgr.registerPanel.gameObject.SetActive(false);
            LoginRegisterExample.PanelMgr.loginPanel.gameObject.SetActive(true);
        });
    }
}

using UnityEngine;

public class LoginRegisterExample : MonoBehaviour
{
    public LoginPanel loginPanel;
    public RegisterPanel registerPanel;

    public static LoginRegisterExample PanelMgr;

    void Awake()
    {
        PanelMgr = this;
    }

    void Start()
    {
        loginPanel = transform.Find("LoginPanel").GetComponent<LoginPanel>();
        registerPanel = transform.Find("RegisterPanel").GetComponent<RegisterPanel>();
        loginPanel.gameObject.SetActive(true);
        registerPanel.gameObject.SetActive(false);
    }
}

四、Unity生命周期与Trigger

Observable.EveryUpdate()就是支持的Unity的API。

单单Update就是支持非常多细分类型的Update事件捕获。

Observable.EveryFixedUpdate().Subscribe(_ => {});
Observable.EveryEndOfFrame().Subscribe(_ => {});
Observable.EveryLateUpdate().Subscribe(_ => {});
Observable.EveryAfterUpdate().Subscribe(_ => {});
除了 Update 还支持其他的事件，⽐如 ApplicationPause，Quit 等。
Observable.EveryApplicationPause().Subscribe(paused => {});
Observable.EveryApplicationFocus().Subscribe(focused => {});
Observable.EveryApplicationQuit().Subscribe(_ => {}):
学习了以上这些，就不用再去创建一个单例类去实现一个诸如“应用程序退出事件监听”这种逻辑了。
命名几行代码就可以搞定的事情，何必再去创建一个类去搞定？

Trigger 简介
Observable.EveryUpdate() 这个 API 有的时候在某个脚本中实现，需要绑定 MonoBehaviour 的生命周期（主要是 OnDestroy），当然也有的时候是全局的，而且永远不会被销毁的。
需要绑定 MonoBehaviour 生命周期的 EveryUpdate。只需要一个 AddTo 就可以进行绑定了。⾮非常简单，代码如下：
Observable.EveryUpdate()
.Subscribe(_ => {})
.AddTo(this);
但其实有更简洁的实现:

this.UpdateAsObservable()
.Subscribe(_ => {});

（命名空间：Using UniRx.Triggers;）

这种类型的 Observable 是什么呢？
答案是：Trigger，即触发器。
字如其意，很容易理解。

Trigger 类型的关键字
触发器，字如其意，是当某个事件发生时，则会将该事件发送到 Subscribe 函数中，而这个触发器，本身是一个功能脚本，这个脚本挂在 GameObject 上，来监听 GameObject 的某个事件发⽣生，事件发生则会回调给注册它的 Subscribe 中。触发器的操作和其他的事件源 (Observable) 是一样的，都支持 Where、First、Merge 等操作符。
Trigger 类型的 Observable 和我们之前讲的所有的 Observable 在表现上有一点不一样:
1. Trigger 大部分都是 XXXAsObsrevable 命名形式的。
2. 在使用 Trigger 的 GameObject 上都会挂上对应的 Observable XXXTrigger.cs 的脚本。

Trigger 在此之前我们是接触过的。
AddTo() 这个 API 其实是封装了一种 Trigger: ObservableDestroyTrigger。
顾名思义，就是当 GameObject 销毁时获取事件的一个触发器。
一般的 Trigger 都会配合 MonoBehaviour 一起使用。
比如 ObservableDestroyTrigger 的使用代码如下:

this.OnDestroyAsObservable()
.Subscribe(_ => {});
除了 Destroy 还有非常多的 Trigger。
比如各种细分类型的 Update:
this.FixedUpdateAsObservable().Subscribe(_ => {});
this.LateUpdateAsObservable().Subscribe(_ => {});
this.UpdateAsObservable().Subscribe(_ => {});
还有各种碰撞的 Trigger:

this.OnCollisionEnterAsObservable(collision => {});
this.OnCollisionExitAsObservable(collision => {});
this.OnCollisionStayAsObservable(collision => {});
// 同样 2D 的也支持
this.OnCollision2DEnterAsObservable(collision2D => {});
this.OnCollision2DExitAsObservable(collision2D => {});
this.OnCollision2DStayAsObservable(collision2D => {});
一些脚本的参数监听:
this.OnEnableAsObservable().Subscribe(_ => {});
this.OnDisableAsObservable().Subscribe(_ => {});

除了 MonoBehaviour ，Trigger 也支持了其他组件类型，比如 RectTransform、Transform、
UIBehaviour 等等。这里不再赘述。
详情可以查看 ObservableTriggerExtensions.cs 和 ObervableTriggerExtensions.Component.cs 中的API。

五、UI Triggers

Trigger 也有支持 UI 的部分。
在上堂课的结尾说过，Trigger 除了 MonoBehaviour 还支持其他的类型，比如 Transform、
RectTransform、还有 UIBehaviour。
那么这个 UIBehaviour 就是本文要讲解的重点。
为什么?
因为 UIBehaivour 是 UGUI 所有控件的基类。
只要支持 UIBehaivour，就支持所有的 UGUI 控件等会继承 UIBehaviour 的支持。

那么从哪方⾯支持呢？
是从各种事件开始支持的。
比如所有的 Graphic 类型都支持 OnPointerDownAsObservable、OnPointerEnterAsObservable、OnPointerEnterAsObservable 等 Trigger。
Graphic 简单介绍下，所有的在 Inspector 上显示，Raycast Target 选定框的都是 Graphic 类型，包括Image、Text 等全部都是。

也就是说 Image、Text 全部支持 OnPointerDownAsObservable、OnPointerEnterAsObservable 等Trigger。
我们知道，如果想自己去接收一个 OnPointerDown 事件，需要实现一个 IPointerDownHandler 接口，而 UniRx 则把所有的 IXXXHandler 接口都做成 Trigger了。
这样再也不⽤需要网上到处流传的 UIEventListener.Get(gameObejct).onClick 这种方式了。
因为这种方式问题很多，比如，由于它继承了 EventTriggers，实现了所有的事件接口，他就会吞噬掉OnScroll 等事件。
而 UniRx 的实现非常细，也就是一个 IXXXHandler 就是一个 Trigger（本来老师的 QFramework 也想全部都实现了）。需要一个全部实现并且吞并事件的版本也没关系，UniRx 也实现了一个 ObservableEventTrigger。和UIEventListener 一样的。
老师在项目中用的比较多的几个 Trigger:

mImage.OnBeginDragAsObservable().Subscribe(dragEvent => {});
mGraphic.OnDragAsObservable().Subscribe(dragEvent => {});
mText.OnEndDragAsObservable().Subscribe(dragEvent => {});
mImage.OnPointerClickAsObservable().Subscribe(clickEvent => {});
非常方便，导致 QFramework 的一些脚本都弃用了，哈哈哈。
除了常用的几个 Trigger 之外还有非常多的实用的 Trigger。比如: OnSubmitAsObservable、OnDropAsObservable 等等。
具体可以参考 ObservableTriggerExtensions.Component.cs，只要能想到的基本上 UniRx 都支持。
忘了说一点，要使用各种 Trigger 类型，就要导入命名空间: using UniRx.Triggers;

六、Coroutine的操作

UniRx 对 Unity 的 Coroutine 也提供支持，可以将一个 Coroutine 转化为事件源（Observable）。

using System.Collections;
using UnityEngine;
using UniRx;

public class RxCoroutineTest : MonoBehaviour
{
    IEnumerator CoroutineA()
    {
        yield return new WaitForSeconds(1f);
        Debug.Log("A");
    }

    void Start()
    {
        Observable.FromCoroutine(_ => CoroutineA())
            .Subscribe(_ =>
            {
                //do something
            }).AddTo(this);
    }
}

一秒之后，输出结果为：
A
非常简单。
当然也支持将 Observable 转化为一个 Coroutine 中的 yield 对象。
比如:

using System.Collections;
using UnityEngine;
using UniRx;
using System;

public class Rx2YieldTest : MonoBehaviour
{
    IEnumerator Delay1Second()
    {
        yield return Observable.Timer(TimeSpan.FromSeconds(1f)).ToYieldInstruction();
        Debug.Log("B");
    }

    void Start()
    {
        StartCoroutine(Delay1Second());
    }
}

一秒之后，输出结果为:
B
FromCoroutine 和 ToYieldInstruction 实现了 Observable 与 Coroutine 之间的互相转化。
而在之前说过，Observable 是一条事件流。UniRx 的操作符，比如 Merge 可以处理多个流，可以将流进行合并。
除了合并也支持别的操作，比如顺序 (依赖) 执行 Coroutine，并行执行 Coroutine 等等。
在之后，通过学习新的操作符，可以让 Coroutine 更加强大。

七、WhenAll:Coroutine 的并行操作

WhenAll 意思是，当所有的。
当所有的什么呢?
就是当所有的事件流都结束，就会触发 Subscribe 注册的回调。
使用 WhenAll 可以实现 Coroutine 的并行操作。

using System.Collections;
using UnityEngine;
using UniRx;

public class WhenAllCoroutineTest : MonoBehaviour
{
    IEnumerator A()
    {
        yield return new WaitForSeconds(1f);
        Debug.Log("A");
    }

    IEnumerator B()
    {
        yield return new WaitForSeconds(2f);
        Debug.Log("B");
    }

    void Start()
    {
        var aStream = Observable.FromCoroutine(_ => A());
        var bStream = Observable.FromCoroutine(_ => B());
        Observable.WhenAll(aStream, bStream)
            .Subscribe(_ =>
            {

            }).AddTo(this);
    }
}

一秒后输出结果为:
A
两秒后输出结果为:
A
B
WhenAll 和 Merge 是同类型的，是处理多个流的操作符。
理解起来非常简单。
除了并行实现 Coroutine 之外，还可以实现，当所有的按钮都点击过一次的逻辑。

using UnityEngine;
using UnityEngine.UI;
using UniRx;

public class ButtonAllClickedOnce : MonoBehaviour
{
    [SerializeField] Button mButtonA;
    [SerializeField] Button mButtonB;
    [SerializeField] Button mButtonC;

    void Start()
    {
        var aStream = mButtonA.OnClickAsObservable().First();
        var bStream = mButtonB.OnClickAsObservable().First();
        var cStream = mButtonC.OnClickAsObservable().First();

        Observable.WhenAll(aStream, bStream, cStream)
            .Subscribe(_ =>
            {
                Debug.Log("三个按钮都点击了");
            }).AddTo(this);
    }
}

当点击完，A、B、C 按钮之后就会输出:
三个按钮都点击了
WhenAll 可以配合非常多的操作符使用。理解也非常简单。

八、事件流的结束OnCompleted

UniRx的结束事件。

有的事件流是有结束事件的，比如 Timer、First、Coroutine 等。
有的则没有，比如 EveryUpdate 等。
使用 Subscribe API 进行订阅的时候，第一个参数是 OnNext 回调的注册，这也是我们大部分情况下使用的回调。第二个蚕⻝则是 OnComplete
代码如下:

using System.Collections;
using UnityEngine;
using UniRx;

public class OnCompletedExample : MonoBehaviour
{
    void Start()
    {
        Observable.FromCoroutine(A)
            .Subscribe(_ =>
            {
                Debug.Log("接下来");
            }, () =>
             {
                 Debug.Log("完成");
             });
    }

    IEnumerator A()
    {
        yield return new WaitForSeconds(2f);
    }
}

2 秒后输出结果为:

接下来

完成

九、Start:让多线程更简单

多线程，是作为高级开发者必须具备的一种技术。了解了多线程可以让我们充分利用多核移动端的计算优势，也可以让我们的游戏体验更平滑。
在 Unity 中我们一般用 Thread.Start 开启一个线程。当逻辑非常复杂的时候多线程非常难以管理理。
而 UniRx 改善了这一种状况。
一个”当所有线程运行完成后，在主线程执行某个任务” 这个功能，使用 UniRx 实现如下:

using System;
using UnityEngine;
using UniRx;

public class ThreadTest : MonoBehaviour
{
    void Start()
    {
        var threadAStream = Observable.Start(() =>
          {
              System.Threading.Thread.Sleep(TimeSpan.FromSeconds(1));
              return 10;
          });

        var threadBStream = Observable.Start(() =>
          {
              System.Threading.Thread.Sleep(TimeSpan.FromSeconds(3));
              return 10;
          });

        Observable.WhenAll(threadAStream, threadBStream)
            .ObserveOnMainThread()
            .Subscribe(xs =>
            {
                Debug.Log(xs[0] + ":" + xs[1]);
            });
    }
}

3 秒后，输出的结果如下:
10:10
这里有两个新的 API，一个是 Observable.Start，这个 API 意思开启一个线程流。
ObserveOnMainThread，意思是把 WhellAll 结果转到主线程上。这样 Subscribe 里的回调就可以使用Unity 的 API 了（Unity 的很多 API 不可以在其他线程中使用）。
使用 UniRx 来处理线程逻辑非常简单。
线程和 Coroutine (协程）都可以使用 WhenAll 这种操作符。
除了WhenAll，还有很多其他的操作符，我们在之后慢慢学习。

十、ObservableWWW 优雅的网络请求操作

以往我们不管使用 WWW 还是 UnityWebRequest 都要使用 Coroutine 去驱动。
但是使用协程写出来的代码，需要一堆判断，导致代码非常混乱。
而 UniRx 则是以往一样简练的风格提供了对网络请求的支持。
代码如下:

ObservableWWW.Get("http://sikiedu.com")
            .Subscribe(_ =>
            {
                //todo something
            }).AddTo(this);

非常简单。
当然，ObservableWWW 同样支持 WhenAll 操作符。
代码如下:

var aStream = ObservableWWW.Get("http://sikiedu.com");
        var bStream = ObservableWWW.Get("http://qframework.io");
        Observable.WhenAll(aStream,bStream)
            .Subscribe(_ =>
            {
                //todo something
            }).AddTo(this);

除了 Get 也支持了Post，还有 GetWWW 和 PostWWW 这种的辅助封装，还有 GetAndGetBytes 和PostAndGetBytes。
列出 QFramework 中一段下载文件的代码:

// http://liangxiegame.com/media/QFramework_v0.0.9.unitypackage
protected override void OnBegin()
{
...
var progressListener = new ScheduledNotifier<float>();
ObservableWWW.GetAndGetBytes(mRequestPackageData.DownloadUrl, null,
progressListener)
.Subscribe(bytes =>
{
...
});
progressListener.Subscribe(OnProgressChanged);
}
private void OnProgressChanged(float progress)
{
EditorUtility.DisplayProgressBar("插件更更新",
"插件下载中 {0:P2}".FillFormat(progress), progress);
}

ObservableWWW 的 API 都可以传进去一个 ScheduledNotifier<T>() ，用来监听下载进度的。
Subscribe 之后传回来的值则是，当前的进度。
而且 ObservableWWW 的 Get 和 Post 请求都可以自己传对应的 header 和 WWWForm。
除了常用的 Get 和 Post 请求，也对 AssetBundle 的加载也做了简单的封装。
提供了诸如 ObservableWWW.LoadFromCacheOrDownload 这样的 API。

如果想深⼊了解，可以参考 ObservableWWW.cs
总之对 WWW 提供的 API 非常简练，也足够使用。

十一、ReactiveCommand

我们先来看下 ReactiveCommand 定义

public interface IReactiveCommand<T> : IObservable<T>
{
IReadOnlyReactiveProperty<bool> CanExecute { get; }
bool Execute(T parameter);
}

它提供了两个 API:
• CanExecte
• Execute
Execute 方法是被外部调用的。也就是这个 Command 的执行。这个很容易理解，只要外部调用的
Execute 就会执行。
而 CanExecute 则是内部使用的，并且对外部提供了只读访问。
当 CanExecute 为 false 时，在外部调用 Execute 则该 Command 不会被执行。
当 CanExecute 为 true 时，在外部调用 Execute 则该 Command 会被执行。
是什么决定 CanExecute 为 false 或 true 呢?
答案是其他的 Observable。
新创建的 ReactiveCommand 默认 CanExecute 为 true。
我们看下代码就好了。

using UnityEngine;
using UniRx;

public class ReactiveCommandExample : MonoBehaviour
{
    void Start()
    {
        ReactiveCommand command = new ReactiveCommand();
        command.Subscribe(_ =>
        {
            Debug.Log("command executed");
        });

        command.Execute();
        command.Execute();
        command.Execute();
    }
}

输出结果为:
command executed
command executed
command executed
非常地简单，只要调用 Execute。command 就会通知 Subscribe 的回调(因为 CanExecute 为 true)。
CanExecute 的开启关闭是由 Observable （事件源）决定的。

示例代码如下:

using UnityEngine;
using UniRx;

public class MouseUpExample : MonoBehaviour
{
    void Start()
    {
        var leftMouseClickStream = Observable.EveryUpdate().Where(_ =>
          Input.GetMouseButtonDown(0)).Select(_ => true);
        var rightMouseClickStream = Observable.EveryUpdate().Where(_ =>
          Input.GetMouseButtonUp(0)).Select(_ => false);
        var mouseUp = Observable.Merge(leftMouseClickStream, rightMouseClickStream);
        var reactiveCommand = new ReactiveCommand(mouseUp, false);
        reactiveCommand.Subscribe(x =>
        {
            Debug.Log(x);
        });
        Observable.EveryUpdate()
            .Subscribe(_ =>
            {
                reactiveCommand.Execute();
            });
    }
}

当按下鼠标时持续输出 ”()”，当抬起鼠标时，则停止输出。
非常容易理解。
当然 ReactiveCommand 也是可以被订阅(Subscribe) 的，在订阅之前呢，也可以使用 Where 等操作符进行事件操作。
示例代码如下:

using UnityEngine;
using UniRx;

public class OperatorExample : MonoBehaviour
{
    void Start()
    {
        var reactiveCommand = new ReactiveCommand<int>();
        reactiveCommand.Where(x => (x % 2 == 0)).Subscribe(x =>
              Debug.LogFormat("{0} is Even numbers",x));
        reactiveCommand.Where(x => (x % 2 != 0)).Timestamp().Subscribe(x =>
              Debug.LogFormat("{0} is Odd,{1}", x.Value, x.Timestamp));
        reactiveCommand.Execute(2);
        reactiveCommand.Execute(3);
    }
}

输出结果为：

2 is Even numbers

3 is Odd,2021/10/20 6:33:57 +00:00
到此，ReactiveCommand 的基本用法，大家应该掌握了。
我们通过以下两图，简单去理解下 ReactiveCommand 执行原理。

ReactiveCommand 除了能做以上一些简单的事情外，其实可以做非常多强大的功能。
但是要介绍非常强大的功能之前呢，我们要先学好 UniRx 的入门基础及一点点原理。
所以今天呢，只是对 ReactiveCommand 进行了一个简介，在之后呢会对 ReactiveCommand 进行一个深⼊地了解。

十二、ReactiveCollection 与 ReactiveDictionary

ReactiveCollection 类似于 List。
我们可以使用如下的操作符:
ObserverAdd // 当新的 Item 添加则会触发
ObserverRemove // 删除
ObserverReplace // 替换(Update)
ObserverMove // 移动
ObserverCountChanged // 数量有改变(Add、Remove)
ReactiveCollection 示例代码：

using UnityEngine;
using UniRx;

public class ReactiveCollectionExample : MonoBehaviour
{
    ReactiveCollection<int> mAges = new ReactiveCollection<int>
    {
        1,2,3,4,5
    };

    void Start()
    {
        mAges.ObserveAdd()
            .Subscribe(addAge =>
            {
                Debug.LogFormat("add:{0}", addAge);
            });
        mAges.ObserveRemove()
            .Subscribe(removedAge => 
            { 
                Debug.LogFormat("remove:{0}", removedAge); 
            });
        mAges.ObserveCountChanged()
            .Subscribe(count =>
            {
                Debug.LogFormat("count:{0}", count);
            });
        foreach(var age in mAges)
        {
            Debug.Log(age);
        }

        mAges.Add(6);
        mAges.Remove(2);
    }
}

输出结果为
1
2
3
4
5
add:Index:5 Value:6
count:6
remove:Index:1 Value:2
count:5

ReactiveDictionary 功能与 Dictionary 一样。
同样地，它支持了几个操作符:
ObserverAdd // 当新的 Item 添加则会触发
ObserverRemove // 删除
ObserverReplace // 替换(Update)
ObserverMove // 移动
ObserverCountChanged // 数量有改变(Add、Remove)
示例代码如下:

using UnityEngine;
using UniRx;

public class ReactiveDictionaryExample : MonoBehaviour
{
    private ReactiveDictionary<string, string> mLanguageCode = new ReactiveDictionary<string, string>()
    {
        { "en","英语"},
        { "cn","中文"}
    };

    void Start()
    {
        mLanguageCode.ObserveAdd()
            .Subscribe(addedLanguage =>
            {
                Debug.LogFormat("add:{0}", addedLanguage.Value);
            });
        mLanguageCode.ObserveRemove()
             .Subscribe(removedLanguage =>
             {
                 Debug.LogFormat("remove:{0}", removedLanguage.Value);
             }); 
        mLanguageCode.ObserveCountChanged()
              .Subscribe(count =>
              {
                  Debug.LogFormat("count:{0}", count);
              });
        mLanguageCode.Add("jp", "日语");
        mLanguageCode.Remove("en");
    }
}

输出结果为
add:日语
count:3
remove:英语
count:2

十三、加载场景 AsyncOperation

我们在异步加载资源或者异步加载场景的时候往往会用到 AsyncOperation。
UniRx 对 AsyncOperation 做了支持。使得加载操作可以很容易地监听加载进度。
示例代码如下:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
using UniRx;

public class AsyncOperationExample : MonoBehaviour
{
    void Start()
    {
        var progressObservable = new ScheduledNotifier<float>();
        SceneManager.LoadSceneAsync(0).AsAsyncOperationObservable(progressObservable)
            .Subscribe(ssyncOperation =>
            {
                Debug.Log("load done");
            });
        Resources.LoadAsync<GameObject>("TestCanvas").AsAsyncOperationObservable()
            .Subscribe(resourceRequest =>
            {
                Instantiate(resourceRequest.asset);
            });
        progressObservable.Subscribe(progress =>
        {
            Debug.LogFormat("加载了：{0}", progress);
        });
    }
}

输出结果为:
加载了:0.9
加载了:0.9
加载了:1
load done

[TodoList实战]

1.TodoList功能定义

TodoList App是一个待办事项应用。

功能如下：

（1）待办清单可以添加、更改、删除待办事项；

（2）待办事项可以完成，其内容可以编辑；

林枫依依

关注

1
点赞
踩
19

收藏

觉得还不错? 一键收藏
打赏
0
评论
【UniRx】第一季：入门精讲

前提：本人用的Unity2019.3.0f3，从AssetStore上直接下的UniRx 7.1.0;（摘自凉鞋）一、UniRx简介UniRx 是⼀一个 Unity3D 的编程框架。专注于解决异步逻辑，使得异步逻辑的实现更更加简洁优雅。简洁优雅如何体现?⽐比如，实现⼀一个”只处理理第⼀一次⿏鼠标点击事件”这个功能，使⽤用 UniRx 实现如下：void Start() { Observable.EveryUpdate()
复制链接

扫一扫