Rx:1-Observable

.net的IEnumerable接口是返回IEnumerator，而IEnumerator实现了MoveNext()和获取当前对象等方法。

Observable利用该思想，使用IObservable<T>和IObserver<T>实现Push-Style（推模式），我们常用的IEnumerble可以理解为拉模式或主动模式，那么就需要返回IEnumerator来操作。而推模式正好相反，所以IObserver<T>是作为IObserverable<T>的参数传进去的：

public interface IObservable<T>
{
    // Methods
    IDisposable Subscribe(IObserver<T> observer);
}

public interface IObserver<T>
{
    // Methods
    void OnCompleted();
    void OnError(Exception exception);
    void OnNext(T value);
}

System.Observable.dll里就只有这两个接口的定义。这个接口是定义在System命名空间下的。

Inactive和Reactive是两种思想，前者是基于状态的，后者是基于事件的。基于事件通知的好处就在于线程不用blocking去wait，所以程序的吞吐量会大大增加。换个角度，可以理解为Inactive就是主动的，Reactive就是被动的。

Reactive这种被动模式常被称作Push模式。这么看到,IObservable就是Push的“来源”（外界推力），IObserver就是“要被推到的目标”。两者通过“目标”的主动订阅（Subscribe方法）来结合，当然，“目标”是可以订阅多个“外界作用力的”。

拿一个从1加到100的例子：

class Program
    {
        /// <summary>
        /// 该方式直接使用Extension method创建匿名的Observer
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            var ob1 = new Ob1();
            ob1.Subscribe(str=>Console.WriteLine(str), ()=>Console.WriteLine("DONE!"));

            Console.WriteLine("has subscribed...");
            ThreadPool.QueueUserWorkItem(obj => ob1.DoJob(obj));
            Console.WriteLine("has started DoJob()\n");

            Console.ReadLine();
        }

        /// <summary>
        /// 这种方式需要一个Observer来相应
        /// </summary>
        private static void Main1()
        {
            var theObserver = new TheObserver();

            var ob1 = new Ob1();
            var unsubscribeHandler = ob1.Subscribe(theObserver);

            Console.WriteLine("has subscribed...");
            ThreadPool.QueueUserWorkItem(obj => ob1.DoJob(obj));
            Console.WriteLine("has started DoJob()\n");

            Console.ReadLine();
        }
    }

    public class TheObserver : IObserver<string>
    {
        public void OnCompleted()
        {
            Console.WriteLine("Completed");
        }

        public void OnError(Exception exception)
        {
            Console.WriteLine(exception.Message);
        }

        public void OnNext(string str)
        {
            Console.WriteLine(str);
        }
    }

    public class Ob1 : IObservable<string>
    {
        private List<IObserver<string>> observers = new List<IObserver<string>>();

        public IDisposable Subscribe(IObserver<string> observer)
        {
            observers.Add(observer);
            return new Unsubscribe(observer, p => observers.Remove(p));
        }

        public void DoJob(object obj)
        {
            var sum = 0;
            try
            {
                for (int i = 0; i < 100; i++)
                {
                    observers.ForEach(p => p.OnNext((++sum).ToString()));
                    Thread.Sleep(30);
                }
            }
            catch (Exception ex)
            {
                observers.ForEach(p=>p.OnError(ex));
            }

            observers.ForEach(p=>p.OnCompleted());
        }
    }

    public class Unsubscribe : IDisposable
    {
        public IObserver<string> Source { get; set; }
        public Action<IObserver<string>> DisposeAction { get; set; }

        public Unsubscribe(IObserver<string> source, Action<IObserver<string>> disposeAction)
        {
            this.Source = source;
            this.DisposeAction = disposeAction;
        }

        public void Dispose()
        {
            DisposeAction(Source);
        }
    }

在System.Reactive.dll里为IObservable<T>提供了如下的扩展方法：

public static class ObservableExtensions
{
    // Methods
    public static IDisposable Subscribe<TSource>(this IObservable<TSource> source);
    public static IDisposable Subscribe<TSource>(this IObservable<TSource> source, Action<TSource> onNext);
    public static IDisposable Subscribe<TSource>(this IObservable<TSource> source, Action<TSource> onNext, Action<Exception> onError);
    public static IDisposable Subscribe<TSource>(this IObservable<TSource> source, Action<TSource> onNext, Action onCompleted);
    public static IDisposable Subscribe<TSource>(this IObservable<TSource> source, Action<TSource> onNext, Action<Exception> onError, Action onCompleted);
}

所以我们更简单的写了：

static void Main(string[] args)
        {
            var observables = Observable.Interval(TimeSpan.FromMilliseconds(30)).TakeWhile(p => p <= 100);
            var newObservable = observables.Select(p => --p);
            observables.Subscribe(p => Console.WriteLine(p));
            newObservable.Subscribe(c => Console.WriteLine("\t" + c));
            Thread.Sleep(3000);
            Console.WriteLine("start");
            Console.ReadLine();
        }

 

这里Line 5的Select方法会在每次生成observables的OnNext的时候调用一次。