UniRx操作符_自Rx.Net

Time:时间

Timer

它在⼀个给定的延迟后发射⼀个值/执行任务

        Observable.Timer(TimeSpan.FromSeconds(1.0), TimeSpan.FromSeconds(0.1f))
                .Subscribe(_ => Debug.Log("after 1 seconds"));

---

Interval

        Observable.Interval(TimeSpan.FromSeconds(0.5f))
                .Subscribe(times => Debug.Log(times));

---

Throttle

节流阀 仅在过了⼀段指定的时间还没发射数据时才发射⼀个数据

        Observable.EveryUpdate()
                .Where(_ => Input.GetMouseButtonDown(0))
                .Throttle(TimeSpan.FromSeconds(1.0f))
                .Subscribe(_ => Debug.Log("after 1 seconds"));

---

Delay

延迟⼀段指定的时间再发射来⾃ Observable 的发射物

        Observable.Timer(TimeSpan.FromSeconds(1.0f))
                      .Select(_ =>
                      {
                          Debug.Log("1 seconds");
                          return _;
                      })
                      .Delay(TimeSpan.FromSeconds(1.0f))
                      .Select(_ =>
                      {
                          Debug.Log("2 seconds");
                          return _;
                      })
                      .Delay(TimeSpan.FromSeconds(1.0f))
                      .Subscribe(_ => Debug.Log("3 seconds"));


            Observable.ReturnUnit()
                .Delay(TimeSpan.FromSeconds(5.0f))
                .Subscribe(_ => Debug.Log("has return"));

---

Sample

定期发射 Observable 最近发射的数据项

定时查看⼀个Observable，然后发射⾃上次采样以来它最近发射的数据

        Observable.EveryUpdate()
                .Where(_ => Input.GetMouseButtonDown(0))
                .Select(_ => clickCount++)
                .Sample(TimeSpan.FromSeconds(3))
                .Subscribe(_ => Debug.LogFormat("第 {0} 次点击", clickCount));

---

Timestamp

给发射的数据项附加⼀个时间戳

        Observable.EveryUpdate()
                .Where(_ => Input.GetMouseButtonDown(0))
                .Timestamp()
                .Subscribe(timestamp => { Debug.LogFormat("timestamp:{0}", timestamp.Timestamp.LocalDateTime); });

---

ThrottleFirst

它总是发射原始的第⼀项数据，⽽不是最近的⼀项
它默认在 computation 调度器上执⾏，但是可以使⽤第三个参数指定其它的调度器

        Observable.EveryUpdate()
                .Where(_ => Input.GetMouseButtonDown(0))
                .ThrottleFirst(TimeSpan.FromSeconds(2.0))
                .Subscribe(_ => Debug.Log("clicked!"));

⿏标点击之后，⽴即输出 “clicked”，输出之后的 2 秒内点击⽆效

---

TimeInterval

将⼀个发射数据的 Observable 转换为发射那些数据发射时间间隔的 Observable

        Observable.EveryUpdate()
                .Where(_ => Input.GetMouseButtonDown(0)).Select(_ => "clicked")
                .TimeInterval()
                .Subscribe(timeInterval => Debug.LogFormat("{0},{1}", timeInterval.Interval, timeInterval.Value));

表示了每次点击之间的 时间间隔

---

Timeout

对原始 Observable 的⼀个镜像，如果过了⼀个指定的时⻓仍没有发射数据，它会发⼀个错误通知，以⼀个 onError 通知
终⽌这个 Observable

       Observable.EveryUpdate()
                      .Where(_ => Input.GetMouseButtonDown(0))
                      .Timeout(TimeSpan.FromSeconds(3.0f))
                      .Subscribe(_ =>
                      {
                          Debug.Log("mouse clicked");
                      });


            ObservableWWW.Get("http://baidu.com")
                         .Timeout(TimeSpan.FromSeconds(0.1f))
                         .Subscribe(_ => { }, e =>
                         {
                             Debug.LogErrorFormat("发生了异常:{0}", e.Message);
                         });

---

Paging:分页

TakeUntil

TakeUntil 订阅并开始发射原始 Observable，它还监视你提供的第⼆个 Observable。如果第⼆个 Observable 发射了⼀项数据或者发射了⼀个终⽌通知， TakeUntil 返回的Observable会停⽌发射原始 Observable 并终⽌

        Observable.EveryUpdate()
                .TakeUntil(Observable.EveryUpdate().Where(_ => Input.GetMouseButtonDown(0)))
                .Subscribe(_ => Debug.Log("123"));

---

SkipUntil

丢弃原始 Observable 发射的数据，直到第⼆个 Observable 发射了⼀项数据

       var clickStream = this.UpdateAsObservable().Where(_ => Input.GetMouseButtonDown(0));

            // 监听
            this.UpdateAsObservable()
                .SkipUntil(clickStream)
                .Take(100)
                .Repeat()
                .Subscribe(_ => Debug.Log("mouse clicked"));

---

Buffer

缓冲

        Observable.Interval(TimeSpan.FromSeconds(1.0f))
                .Buffer(TimeSpan.FromSeconds(4.0f))
                .Subscribe(countList =>
                {
                    Debug.Log("countList");
                    countList.ToList()
                        .ForEach(count => Debug.Log(count));
                });

---

Creation:创建

Return

返回

        Observable.Return(Unit.Default)
                .Delay(TimeSpan.FromSeconds(1.0f))
                .Repeat()
                .Subscribe(_ => Debug.Log("after 1 seconds"));


        Observable.Return("hello")
                .Subscribe(Debug.Log);

---

Defer

直到有观察者订阅时才创建 Observable，并且为每个观察者创建⼀个新的 Observable

        Observable.Defer(() => Observable.Start(() => random.Next()))
                .Delay(TimeSpan.FromMilliseconds(1000))
                .Repeat()
                .Subscribe(randomNumber => Debug.Log(randomNumber));

---

Never

创建⼀个不发射数据也不终⽌的Observable

        var never = Observable.Never<string>();

            never.Subscribe(_ => Debug.Log(_), () => { Debug.Log("completed"); });

---

Create

使⽤⼀个函数从头开始创建⼀个Observable

给这个操作符传递⼀个接受观察者作为参数的函数，编写这个函数让它的⾏为表现为⼀个 Observable ，恰当的调⽤观察者的 onNext， onError 和 onCompleted ⽅法

        Observable.Create<int>(observer =>
            {
                observer.OnNext(1);
                observer.OnNext(2);

                Observable.Timer(TimeSpan.FromSeconds(1.0f))
                    .Subscribe(_ => observer.OnCompleted());

                return Disposable.Create(() => Debug.Log("观察者已销毁"));
            }).Subscribe(number => Debug.LogFormat("number is:{0}", number));

---

Aggregate:聚合

Scan

连续地对数据序列的每⼀项应⽤⼀个函数，然后连续发射结果

对原始Observable发射的第⼀项数据应⽤⼀个函数，然后将那个函数的结果作为⾃⼰的第⼀项数据发射。它将函数的结果同第二项数据⼀起填充给这个函数来产⽣它⾃⼰的第⼆项数据。它持续进⾏这个过程来产⽣剩余的数据序列

        Observable.EveryUpdate()
                .Where(_ => Input.GetMouseButtonDown(0))
                .Scan(0, (times, nextValue) => ++times)
                .Subscribe(times => Debug.LogFormat("clicked {0} times", times));

---

Concatenate:联合

Merge

结合事件流

        var leftClickStream = Observable.EveryUpdate().Where(_ => Input.GetMouseButtonDown(0)).Select(_ => "A");
            var rightClickStream = Observable.EveryUpdate().Where(_ => Input.GetMouseButtonDown(1)).Select(_ => "B");

            leftClickStream.Merge(rightClickStream, rightClickStream)
                .Subscribe(clickEventName => Debug.Log(clickEventName));

---

Switch

订阅⼀个发射多个 Observables 的 Observable。它每次观察那些 Observables 中的⼀个，Switch 返回的这个 Observable 取消订阅前⼀个发射数据的 Observable，开始发射最近的Observable 发射的数据。注意：当原始 Observable 发射了⼀个新的 Observable 时（不是这个新的Observable 发射了⼀条数据时），它将取消订阅之前的那个 Observable。这意味着，在后来那个
Observable 产⽣之后到它开始发射数据之前的这段时间⾥，前⼀个 Observable 发射的数据将被丢弃

        var stateJump = Observable.Return("jump state");
        
            Observable.EveryUpdate()
                .Where(_ => Input.GetKeyDown(KeyCode.Space))
                .Select(_ => stateJump)
                .Switch()
                .Subscribe(stateName => Debug.Log(stateName));


        var wObservable = Observable.EveryUpdate().Where(_ => Input.GetKeyDown(KeyCode.W));
            var aObservable = Observable.EveryUpdate().Where(_ => Input.GetKeyDown(KeyCode.A));
            var sObservable = Observable.EveryUpdate().Where(_ => Input.GetKeyDown(KeyCode.S));
            var dObservable = Observable.EveryUpdate().Where(_ => Input.GetKeyDown(KeyCode.D));
            
            wObservable
                .Select(_ => aObservable)
                .Switch()
                .Select(_ => sObservable)
                .Switch()
                .Select(_ => dObservable)
                .Switch()
                .Repeat()
                .Subscribe(_ => Debug.Log("触发彩蛋"));

---

StartWith

在发射数据之前先发射⼀个指定的数据序列

        Observable.Return("baidu.com")
                      .StartWith("http", "://")
                      .Aggregate((current, next) => current + next)
                      .Subscribe(Debug.Log);

---

CombineLatest

当两个 Observables 中的任何⼀个发射了数据时，使⽤⼀个函数结合每个 Observable 发射的最近数据项，并且基于这个函数的结果发射数据

        var a = 0;
            var i = 0;

            var leftStream = this.UpdateAsObservable().Where(_ =>Input.GetMouseButtonDown(0)).Select(_ => (++a).ToString());
            var rightStream = this.UpdateAsObservable().Where(_ =>Input.GetMouseButtonDown(1)).Select(_ => (++i).ToString());

            leftStream.CombineLatest(rightStream, (left, right) => left + right)
                .Subscribe(Debug.Log);

---

Common:常用

Do

注册⼀个动作作为原始 Observable ⽣命周期事件的⼀种占位符

        Observable.ReturnUnit()
                .Delay(TimeSpan.FromSeconds(1.0f))
                .Do(_ => Debug.Log("after 1 seconds"))
                .Delay(TimeSpan.FromSeconds(1.0f))
                .Do(_ => Debug.Log("after 2 seconds"))
                .Delay(TimeSpan.FromSeconds(1.0f))
                .Do(_ => Debug.Log("after 3 seconds"))
                .Delay(TimeSpan.FromSeconds(1.0f))
                .Do(_ => Debug.Log("after 4 seconds"))
                .Subscribe();

---

Materialize/Dematerialize

Materialize 将数据项和事件通知都当做数据项发射

⼀个合法的有限的 Obversable 将调⽤它的观察者的 onNext ⽅法零次或多次，然后调⽤观察者的 onCompleted 或 onError 正好⼀次。 Materialize 操作符将这⼀系列调⽤，包括原来的 onNext 通知和终⽌通知 onCompleted 或 onError 都转换为⼀个Observable 发射的数据序列

        var subject = new Subject<int>();

            var onlyExceptions = subject.Materialize()
                                        .Where(notification => notification.Exception != null)
                                        .Dematerialize();

            subject.Subscribe(number => Debug.LogFormat("subcribe 1:{0}", number), e => Debug.LogFormat("subcribe excpetion 1:{0}", e));
            onlyExceptions.Subscribe(number => Debug.LogFormat("subcribe 2:{0}", number), e => Debug.LogFormat("subcribe excpetion 2:{0}", e));

            subject.OnNext(123);
            subject.OnError(new Exception("no this vlaue"));

---

IgnoreElements

不发射任何数据，只发射Observable的终⽌通知

操作符抑制原始 Observable 发射的所有数据，只允许它的终⽌通知（onError 或 onCompleted）通过

        var subject = new Subject<int>();

            var noElements = subject.IgnoreElements();

            subject.Subscribe(number => Debug.LogFormat("subject.OnNext({0})", number), () => Debug.Log("subject.OnCompleted()"));
            noElements.Subscribe(number => Debug.LogFormat("noElements.OnNext({0})", number), () => Debug.Log("noElements.OnCompleted()"));

            subject.OnNext(1);
            subject.OnNext(2);
            subject.OnNext(3);

            subject.OnCompleted();

---

DistinctUntilChanged

过掉和之前为相同的

        var state = "runState";

            Observable.EveryUpdate()
                      .DistinctUntilChanged(_ => state)
                      .Subscribe(stateName => Debug.LogFormat("on state changed:{0}", state));


            Observable.ReturnUnit()
                .Delay(TimeSpan.FromSeconds(1.0f))
                .Do(_ => state = "jumpState")
                .Delay(TimeSpan.FromSeconds(1.0f))
                .Do(_ => state = "idleState")
                .Subscribe();



        var subject = new Subject<int>();
            var distinct = subject.DistinctUntilChanged();
            subject.Subscribe(
                i => Debug.LogFormat("{0}", i),
                () => Debug.LogFormat("subject.OnCompleted()"));
            distinct.Subscribe(
                i => Debug.LogFormat("distinct.OnNext({0})", i),
                () => Debug.LogFormat("distinct.OnCompleted()"));
            subject.OnNext(1);
            subject.OnNext(2);
            subject.OnNext(3);
            subject.OnNext(1);
            subject.OnNext(1);
            subject.OnNext(4);
            subject.OnCompleted();

---

Concurrency:并发

Amb

给定两个或多个 Observable 时，它只发射最先发射数据或通知的那个 Observable 的所有数据

        Observable.Amb(
                Observable.Timer(TimeSpan.FromSeconds(4.0f)).Select(_ => "4 sec"),
                Observable.Timer(TimeSpan.FromSeconds(3.0f)).Select(_ => "3 sec"),
                Observable.Timer(TimeSpan.FromSeconds(1.0f)).Select(_ => "1 sec"),
                Observable.Timer(TimeSpan.FromSeconds(7.0f)).Select(_ => "7 sec"),
                Observable.Timer(TimeSpan.FromSeconds(9.0f)).Select(_ => "9 sec")
            ).Subscribe(observableName => { Debug.Log(observableName); });

---

Events:事件

FromEvent

将其它种类的对象和数据类型转换为Observable

        Observable.EveryUpdate()
                      .Where(_ => Input.GetMouseButtonDown(0))
                      .Subscribe(_ => mOnMouseDownEvent.Invoke());

            Observable.FromEvent(mouseDownEvent => mOnMouseDownEvent += mouseDownEvent,
                    mouseDownEvent => mOnMouseDownEvent -= mOnMouseDownEvent)
                   .Subscribe(_ => Debug.Log("mouse clicked"));

---

Bindings:绑定

Publish

将普通的 Observable 转换为可连接的 Observable

可连接的 Observable (connectable Observable)与普通的 Observable 差不多，不过它并不会在被订阅时开始发射数据，⽽是直到使⽤了Connect操作符时才会开始。⽤这种⽅法，你可以在任何时候让⼀个Observable 开始发射数据

        var unShared = Observable.Range(1, 3);

            unShared.Subscribe(number => Debug.LogFormat("unShared Observable #1:{0}", number));
            unShared.Subscribe(number => Debug.LogFormat("unShared Observable #2:{0}", number));

            var shared = unShared.Publish();

            shared.Subscribe(number => Debug.LogFormat("shared Observable #1:{0}", number));
            shared.Subscribe(number => Debug.LogFormat("shared Observable #2:{0}", number));

            Observable.Timer(TimeSpan.FromSeconds(3.0f))
                .Subscribe(_ => shared.Connect());

---

RefCount

让⼀个可连接的 Observable ⾏为像普通的Observable

        var oneSecondPeriod = TimeSpan.FromSeconds(1.0f);

            var refCountObservable = Observable.Interval(oneSecondPeriod)
                                               .Do(l => Debug.LogFormat("Publishing {0}", l))
                                               .Publish()
                                               .RefCount();

            var subscription1 = refCountObservable.Subscribe(l => Debug.LogFormat("subscription #1 : {0}", l));

            yield return new WaitForSeconds(5.0f);


            var subscription2 = refCountObservable.Subscribe(l => Debug.LogFormat("subscription #2  : {0}", l));


            yield return new WaitForSeconds(5.0f);

            subscription1.Dispose();

            yield return new WaitForSeconds(1.0f);

            subscription2.Dispose();

---

Replay

保证所有的观察者收到相同的数据序列，即使它们在Observable开始发射数据之后才订阅

        var replayObservable = Observable.Interval(TimeSpan.FromSeconds(1.0f))
                                             .Do(l => Debug.LogFormat("Observable:{0}", l))
                                             .Replay();

            replayObservable.Subscribe(l => Debug.LogFormat("Subscription #1:{0}", l));
            replayObservable.Connect();

            Observable.Timer(TimeSpan.FromSeconds(5.0f))
                .Subscribe(_ => { replayObservable.Subscribe(l => Debug.LogFormat("Subscription #2:{0}", l)); });

---

ErrorHandling

Catch

从onError通知中恢复发射数据

拦截原始 Observable 的 onError 通知，将它替换为其它的数据项或数据序列，让产⽣的 Observable 能够正常终⽌或者根本不终⽌

        Observable.Throw<string>(new Exception("error"))
                .Catch<string, Exception>(e =>
                {
                    Debug.LogFormat("catched excpetion:{0}", e.Message);
                    return Observable.Timer(TimeSpan.FromSeconds(1.0f))
                        .Select(_ => "timer called");
                })
                .Subscribe(result => Debug.Log(result));

---

Finally

注册⼀个动作，当它产⽣的Observable终⽌之后会被调⽤，⽆论是正常还是异常终⽌

        var subject = new Subject<int>();
            var result = subject.Finally(() => Debug.Log("Finally action run"));

            result.Subscribe(number => Debug.LogFormat("OnNext({0});", number), () => Debug.Log("OnCompleted"));

            subject.OnNext(1);
            subject.OnNext(2);
            subject.OnNext(3);
            subject.OnCompleted();

---

DelaySubscription

        Debug.Log(Time.time);

        Observable.ReturnUnit()
                .DelaySubscription(TimeSpan.FromSeconds(1.0f))
                .Subscribe(_ => Debug.Log(Time.time));

---

PairWise

        Observable.Range(0, 3)
                .Pairwise()
                .Subscribe(pair => Debug.LogFormat("{0}:{1}", pair.Previous, pair.Current));

---