UniRx操作符_自LINQ

Common:常用

Where

过滤操作符

        Observable.EveryUpdate()
            .Where(_ => Input.GetMouseButtonDown(0))
            .Subscribe(_ => { Debug.Log("mouse down"); })
            .AddTo(this);

Select

结果选择操作符

        Observable.EveryUpdate()
            .Where(_ => Input.GetMouseButtonUp(0))
            .Select(_ => "mouse up")
            .Subscribe(Debug.Log)
            .AddTo(this);

Distinct

筛选序列中不相同的值，过滤掉相同的值

            var leftMouseClickStream = Observable.EveryUpdate().Where(_ => Input.GetMouseButtonDown(0))
                .Select(_ => "LeftMouseClicked");
            var rightMouseClickStream = Observable.EveryUpdate().Where(_ => Input.GetMouseButtonDown(1))
                .Select(_ => "RightMouseClicked");

            Observable.Merge(leftMouseClickStream, rightMouseClickStream)
                .Distinct()
                .Subscribe(mouseEvent => { Debug.Log(mouseEvent); });

SelectMany

主要是完成 Coroutine 的顺序执⾏功能

        IEnumerator A()
        {
            yield return new WaitForSeconds(1.0f);
            Debug.Log("A");
        }

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

        IEnumerator C()
        {
            yield return new WaitForSeconds(1.0f);
            Debug.Log("C");
        }

        void Start()
        {
            var aStream = Observable.FromCoroutine(A);
            var bStream = Observable.FromCoroutine(B);
            var cStream = Observable.FromCoroutine(C);

            aStream.SelectMany(bStream.SelectMany(cStream))
                .Subscribe();
        }

ToArray

变成/创建数组

var subjectB = new Subject<int>();
            subject.ToArray().Subscribe(intArray =>
            {
                Debug.Log(intArray.GetType().ToString());
                foreach (var i in intArray)
                {
                    Debug.Log(i);
                }
            });
            subjectB.OnNext(1);
            subjectB.OnNext(2);
            subjectB.OnNext(3);
            subjectB.OnCompleted();

ToList

创建⼀个 List

        var subject = new Subject<float>();

            subject.ToList()
                .Subscribe(timeList =>
                {
                    foreach (var time in timeList)
                    {
                        Debug.Log(time);
                    }
                });

            Observable.Timer(TimeSpan.FromSeconds(1.0f))
                .Repeat()
                .Take(5)
                .Subscribe(_ => subject.OnNext(Time.time), () => subject.OnCompleted());

Paging:分页

First

取序列中的第⼀个元素。 First 有两种形式，⼀种是直接获取第⼀个元素，第⼆种则是取序列中满⾜条件的第⼀个元素。
First 还可以像 Where ⼀样传⼊⼀个条件。

        Observable.EveryUpdate()
            .First(_ => Input.GetMouseButtonDown(0))
            .Subscribe(_ => { Debug.Log("mouse down"); })
            .AddTo(this);

Last

取序列中的最后⼀个元素，Last 里⽀持传⼊⼀个条件函数

            var obserble = Observable.Create<int>(observer =>
            {
                observer.OnNext(3);
                observer.OnNext(2);
                observer.OnNext(1);
                observer.OnCompleted();
                return Disposable.Create(() => { Debug.Log("dispose"); });
            });

            obserble.Last(number=>number > 1)
                    .Subscribe(value =>
                    {
                        Debug.Log(value);
                    });

Take

从序列的开头返回指定数量的元素

        Observable.EveryUpdate()
                .Where(_ => Input.GetMouseButtonDown(0))
                .Take(5)
                .Subscribe(_ => { Debug.Log("mouse clicked!"); });

只会输出鼠标点击的前五下

Skip

跳过序列中指定数量的元素，然后返回剩余的元素

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

GroupBy

对序列中的元素进⾏分组

        var subject = new Subject<int>();

            subject.GroupBy(number => number % 2 == 0 ? "偶数" : "奇数")
                .Subscribe(numberGroup =>
                {
                    numberGroup.Subscribe(number =>
                    {
                        Debug.LogFormat("GroupKey:{0} Number:{1}", numberGroup.Key, number);
                    });
                });


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

            subject.OnCompleted();

TakeWhile

如果指定的条件为 true，则返回序列中的元素，否则停止并跳过剩余的元素

        Observable.EveryUpdate()
                      .Where(_ => Input.GetMouseButton(0))
                      .TakeWhile((_, number) => !Input.GetMouseButtonUp(0) && number < 100)
                      .Subscribe(_ => Debug.Log("mouse button clicking"));
            

            var fruitsBeforeOrange = Observable.Create<string>(observer =>
            {
                observer.OnNext("apple");
                observer.OnNext("banana");
                observer.OnNext("mango");
                observer.OnNext("orange");
                observer.OnNext("passionFruit");
                observer.OnNext("grape");
                observer.OnNext("pink");

                return Disposable.Create(() => { Debug.Log("dispose"); });
            });

            fruitsBeforeOrange.TakeWhile(fruit => fruit != "orange")
                .Subscribe(value => { Debug.Log(value); });

SkipWhile

如果指定的条件为 true，则跳过序列中的元素，然后返回剩余的元素

        Observable.EveryUpdate()
                      .SkipWhile((_,times) => !Input.GetMouseButtonDown(0) && times < 100)
                      .Subscribe(_ => Debug.Log("mouse clicked"));

TakeLast

获取序列的最后⼏项

        Observable.Range(5, 5)
                .TakeLast(3)
                .Subscribe(number => Debug.Log(number));

Single

返回序列中的单个特定元素，与 First 类似，但是 Single 要确保其满⾜条件的元素在序列中只有⼀个

        var subject = new Subject<int>();

            subject.Where(number => number % 2 == 0)
                .Single()
                .Subscribe(number => Debug.Log(number));

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

            subject.OnCompleted();



            string[] fruits =
            {
                "apple", "banana", "mango",
                "orange", "passionfruit", "grape"
            };
            
            fruits.ToObservable().Single(fruit => fruit.Length > 10)
                .Subscribe(Debug.Log);

Concatenate:联合

WhenAll

判定是否Observable发射的所有数据都满⾜某个条件，返回一个布尔值

这里为多个方法条件，全部做完后，返回

        IEnumerator A()
        {
            yield return new WaitForSeconds(1.0f);
            Debug.Log("A");
        }

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

        void Start()
        {
            var leftClickStream = Observable.EveryUpdate().Where(_ => Input.GetMouseButtonDown(0)).Take(3).Select(_ =>
            {
                Debug.Log("left mouse clicked");
                return Unit.Default;
            });

            var rightClickStream = Observable.EveryUpdate().Where(_ => Input.GetMouseButtonDown(1)).Take(4).Select(_ =>
            {
                Debug.Log("right mouse clicked");
                return Unit.Default;
            });

            Observable.WhenAll(Observable.FromCoroutine(A),
                    Observable.FromCoroutine(B),
                    leftClickStream,
                    rightClickStream)
                .Subscribe(_ => { Debug.Log("all coroutine completed"); });
        }

Concat

联合操作符，连接多个 Observable 的输出

        var leftMouseClickStream = Observable.EveryUpdate().Where(_ => Input.GetMouseButtonDown(0)).Take(3)
                .Select(_ => "A");
            var rightMouseClickStream = Observable.EveryUpdate().Where(_ => Input.GetMouseButtonDown(1)).Take(2)
                .Select(_ => "B");

            leftMouseClickStream.Concat(rightMouseClickStream)
                .Subscribe(clickEvent => { Debug.Log(clickEvent); });

Zip

这是在 .Net4 ⽀持的操作符

将指定函数应⽤于两个序列的对应元素，以⽣成结果序列

这里每有一对左右键点击过后就会输出一次 OK

        var leftStream = Observable.EveryUpdate().Where(_ => Input.GetMouseButtonDown(0));
            var rightStream = Observable.EveryUpdate().Where(_ => Input.GetMouseButtonDown(1));

            leftStream.Zip(rightStream, (left, right) => Unit.Default)
                .Subscribe(_ => Debug.Log("ok"));

Creation:创建

Range

⽣成指定范围内的整数的序列

        Observable.Range(5, 10).Select(x => x * x)
                      .Subscribe(number =>
                      {
                          Debug.Log(number);
                      });

Repeat

在⽣成序列中重复生成

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

Empty

返回具有指定类型参数的空

Aggregate:聚合

Aggregate

对序列应⽤累加器函数。将指定的种⼦值⽤作累加器的初始值，并使⽤指定的函数选择结果值
可以轻易的想到一个相对应的应用场景——求阶乘的值，求总和的值

        var subject = new Subject<int>();

            subject.Aggregate((max, nextValue) => max > nextValue ? max : nextValue)
                   .Subscribe(result => Debug.Log(result));

            subject.OnNext(1);
            subject.OnNext(3);
            subject.OnNext(100);
            subject.OnNext(50);
            subject.OnCompleted();


            Observable.Range(0, 8)
                .Aggregate(0, (acc, currentValue) => acc + 5)
                .Subscribe(xx => { Debug.Log(xx); });

Convertions:转换

OfType

根据指定类型筛选元素

        public class Enemy
        {
            public string Name { get; set; }
        };

        public class Boss : Enemy
        {
        };

        public class Monster : Enemy
        {
        };

        void Start()
        {
            var subject = new Subject<Enemy>();

            subject
                .OfType<Enemy, Boss>()
                .Subscribe(boss => { Debug.Log(boss.Name); });

            subject.OnNext(new Boss {Name = "蘑菇王"});
            subject.OnNext(new Monster {Name = "蘑菇"});
            subject.OnNext(new Boss {Name = "阿龙"});

            subject.OnCompleted();
        }

Cast

将元素强制转换为指定的类型

        var subject = new Subject<object>();

            subject.Cast<object, string>()
                .Subscribe(value => Debug.Log(value), e =>
                {
                    Debug.Log("has exception");
                    Debug.LogException(e);
                });

            subject.OnNext("123123");
            subject.OnNext("123123");
            subject.OnNext(123);
            subject.OnCompleted();

目录