基础教程

EveryUpdate —— 更新

观察.Update.订阅(要做的事)

UniRx 就是这样的写法，其他写法主体几乎不变，只是扩展

using UniRx;
using UnityEngine;

public class ChinarUpdate : MonoBehaviour
{
    /// <summary>
    /// 初始化函数
    /// </summary>
    void Start()
    {
        //观察.Update.订阅(要做的事)
        Observable.EveryUpdate().Subscribe(_ =>
        {
            if (Input.GetMouseButtonDown(0))
            {
                print("鼠标左键");
            }
        });
        Observable.EveryUpdate().Subscribe(_ =>
        {
            if (Input.GetMouseButtonDown(1))
            {
                print("鼠标右键");
            }
        });
    }
}

First —— 首次执行

AddTo —— 控制生命周期

First(条件) —— 条件：只在第一次满足条件时，通过

AddTo（对象）——事件流的生命周期

首次点击鼠标左键，输出“只执行一次”，以后不再执行

void Start()
{
    Observable.EveryUpdate()                   //观察
        .First(_ => Input.GetMouseButtonUp(0)) //条件
        .Subscribe(_ => print("只执行一次"))        //订阅
        .AddTo(this);                          //给事件流添加声明周期(PS：何时消失)
}

void Start()
{
    //如果不添加 this ，那 Observable就是全局的，这个方法在重载场景时不会被释放，会无限叠加
    Observable.EveryUpdate().Subscribe(_ => print("Chinar")).AddTo(this);
    this.UpdateAsObservable().Subscribe(_ => print("Chinar")); //等同于上边:省去了AddTo，this指明了事件流的对象生命周期
}

Ui Event —— 界面事件交互

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


/// <summary>
/// UI相关、按钮、图片、文本框
/// 脚本挂载：Canvas
/// </summary>
public class ChinarUguiOnClick : MonoBehaviour
{
    private ReactiveProperty<int> testIntProperty = new ReactiveProperty<int>(88); //指明响应属性 int，值88


    /// <summary>
    /// 初始化函数
    /// </summary>
    void Start()
    {
        //按钮的事件绑定
        //不添加 add to，绑定的监听函数不会叠加
        transform.Find("Button").GetComponent<Button>().OnClickAsObservable().Subscribe(_ => print("按钮事件被执行"));
        transform.Find("Reload Button").GetComponent<Button>().OnClickAsObservable().Subscribe(_ => { SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex); }); //重载当前场景

        //图片的事件注册
        var image = transform.Find("Image").GetComponent<Image>();
        image.OnBeginDragAsObservable().Subscribe(_ => print("开始拖动"));
        image.OnDragAsObservable().Subscribe(_ =>
        {
            print("正在拖动");
            image.transform.position = Input.mousePosition; //移动图
        });
        image.OnEndDragAsObservable().Subscribe(_ => print("拖动完成"));

        //响应 int 直接订阅 Text
        testIntProperty.SubscribeToText(GameObject.Find("Text Subscribe").GetComponent<Text>());
    }
}

Button —— AsObservable

GetComponent<Button>().OnClickAsObservable().Select(_=>"A")//按钮绑定

GetComponent<Button>().OnPointerClickAsObservable().Subscribe();//支持Ui Event各种事件

Coroutine —— 协程

Observable.FromCoroutine(协程函数) —— 协程转 Observable

Observable.Timer(TimeSpan.FromSeconds(1)).ToYieldInstruction() —— Observable 转 Yield

    void Start()
    {
        Observable.FromCoroutine(TestIEnumerator); //协程转 Observable
    }


    private IEnumerator TestIEnumerator()
    {
        yield return Observable.Timer(TimeSpan.FromSeconds(1)).ToYieldInstruction(); // 转 指令、
        print("Chinar Test-Func");
    }

WhenAll —— 等待执行完毕

Where() —— 当多个事件流，需要根据逻辑满足所有都执行后，才触发执行

1：等待2个协程执行完毕 2：当所有事件执行完毕后

    void Start()
    {
        //第一种：等待协程都执行完毕
        var streamA = Observable.FromCoroutine(A);
        var streamB = Observable.FromCoroutine(B);
        Observable.WhenAll(streamA, streamB).Subscribe(_ => print("WenAll执行成功！"));

        //第二种：所有操作执行一次后，执行以下订阅
        var event1 = this.UpdateAsObservable().Where(_ => Input.GetMouseButtonDown(0)).First();
        var event2 = this.UpdateAsObservable().Where(_ => Input.GetMouseButtonDown(1)).First();
        Observable.WhenAll(event1, event2).Subscribe(_ => print("左右键执行一次后，执行操作！"));
    }


    IEnumerator A()
    {
        yield return new WaitForSeconds(1);
        print("A");
    }


    IEnumerator B()
    {
        yield return new WaitForSeconds(2);
        print("B");
    }

Thread —— 线程

Observable.Start() —— 开启一个线程

ObserveOnMainThread() —— 线程结果返回到主线程中，在主线程中观察

    void Start()
    {
        var stream1 = Observable.Start(() =>
        {
            Thread.Sleep(5000);//5000毫秒
            print("等待了5秒");
            return 1;
        }); //线程1
        var stream2 = Observable.Start(() =>
        {
            Thread.Sleep(TimeSpan.FromSeconds(2));
            print("等待2秒");
            return 2;
        }); //线程2

        
        Observable.WhenAll(stream1, stream2).ObserveOnMainThread().Subscribe(_ => //当线程执行完毕，将其他线程中的值，返回到主线程中
        {
            print(_[0]);
            print(_[1]);
        });
    }

ObservableWWW —— RX-WWW请求

new ScheduledNotifier() —— 声明一个预定进度对象

ObserveOnMainThread() —— 线程结果返回到主线程中，在主线程中观察

        //第一个 print，请求正常信息
        //第二个 print，错误信息
        ObservableWWW.Get("http://www.chinar.xin/asdf").Subscribe(print, print);//请求一个错误的网路地址

    void Start()
    {
        var slider           = GameObject.Find("Slider").GetComponent<Slider>();                                                                    //滑动器
        var progressText     = GameObject.Find("ProgressText").GetComponent<Text>();                                                                //进度条文本
        var progressNotifier = new ScheduledNotifier<float>();                                                                                      //RX 预定通知 float
        ObservableWWW.GetAndGetBytes("http://www.chinar.xin/TestUpdate/granulesprite.unity3d", progress: progressNotifier).Subscribe(bytes => { }); //下载完成，做储存
        progressNotifier.Subscribe(progressFloat => { slider.value = progressFloat; });                                                             //更新进度
        progressNotifier.SubscribeToText(progressText);                                                                                             //进度值显示在 progressText
    }