如何实现IObservable

IObservable是一个接口，用于实现观察者模式中的被观察者对象。它是Rx（Reactive Extensions）库中的一部分，用于处理异步和事件驱动的编程。

IObservable接口定义了一组方法，包括订阅观察者、取消订阅观察者以及通知观察者等。通过实现IObservable接口，可以创建可观察的序列，当序列中的数据发生变化时，观察者将收到通知。

实现IObservable的关键是创建一个类，该类应该维护一个观察者列表，并提供方法来订阅和取消订阅观察者。当数据发生变化时，该类应该遍历观察者列表，并调用观察者的相应方法来通知它们。

以下是一个简单的示例代码，展示了如何实现IObservable接口：

using System;
using System.Collections.Generic;

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

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

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

    public IDisposable Subscribe(IObserver<T> observer)
    {
        observers.Add(observer);
        return new Unsubscriber(observers, observer);
    }

    public void Notify(T value)
    {
        foreach (var observer in observers)
        {
            observer.OnNext(value);
        }
    }

    private class Unsubscriber : IDisposable
    {
        private List<IObserver<T>> _observers;
        private IObserver<T> _observer;

        public Unsubscriber(List<IObserver<T>> observers, IObserver<T> observer)
        {
            _observers = observers;
            _observer = observer;
        }

        public void Dispose()
        {
            if (_observer != null && _observers.Contains(_observer))
            {
                _observers.Remove(_observer);
            }
        }
    }
}

// 使用示例
public class Program
{
    public static void Main()
    {
        var observable = new Observable<int>();

        var observer1 = new Observer<int>("Observer 1");
        var observer2 = new Observer<int>("Observer 2");

        using (observable.Subscribe(observer1))
        {
            observable.Notify(1);
            observable.Notify(2);
            observable.Notify(3);
        }

        observable.Subscribe(observer2);

        observable.Notify(4);
        observable.Notify(5);
        observable.Notify(6);
    }
}

public class Observer<T> : IObserver<T>
{
    private string _name;

    public Observer(string name)
    {
        _name = name;
    }

    public void OnNext(T value)
    {
        Console.WriteLine($"{_name} received value: {value}");
    }

    public void OnError(Exception error)
    {
        Console.WriteLine($"{_name} received an error: {error.Message}");
    }

    public void OnCompleted()
    {
        Console.WriteLine($"{_name} completed");
    }
}

在上述示例中，我们定义了IObservable和IObserver接口，然后实现了一个Observable类来实现IObservable接口。Observable类维护了一个观察者列表，并在数据发生变化时通知观察者。

在Main方法中，我们创建了一个Observable实例，并创建了两个观察者实例。通过调用Subscribe方法，观察者订阅了被观察者。然后，我们通过调用Notify方法来通知观察者，它们将收到相应的通知。

这只是一个简单的示例，实际上，IObservable和IObserver接口在Rx库中有更多的功能和扩展。在实际应用中，可以使用Rx库来更方便地处理异步和事件驱动的编程，实现更复杂的观察者模式。