Should I use List <IObserver> or just Action <T> to track IObservable subscribers?

Question

I am implementing an interface IObservable<T>for some classes. I used Reflector to figure out how this is usually done in Rx . As for how the observable tracks its subscribers and notifies them through its method OnNext, I came across a code like this:

private List<Observer<T>> observers;

// subscribe a new observer:
public IDisposable Subscribe(IObserver<T> observer)
{
    observers.Add(observer);
    ...
}

// trigger all observers' OnNext method:
...
foreach (IObserver<T> observer in observers)
{
    observer.OnNext(value);
}

Since all delegates are multi-sheeted, this could not be simplified:

Action<T> observers;

// subscribe observer:
public IDisposable Subscribe(IObserver<T> observer)
{
    observers += observer.OnNext;
    ...
}

// trigger observers' OnNext:
...
observers(value);

---

Or are there certain advantages to the first approach (performance, threads / concurrency problems, & hellip;)?

Answer 1

:

• , , , .
• , .
• , ( , ).

Answer 2

IObservable<T> , IObservable<T> , (, Observable.Create).

, , Subject<T>, concurrency :

public class CustomObservable<T> : IObservable<T>
{
    private Subject<T> subject = new Subject<T>();

    public IDisposable Subscribe(IObserver<T> observer)
    {
        return subject.Subscribe(observer);
    }

    private void EmitValue(T value)
    {
        subject.OnNext(value);
    }
}

NB: ( - ), , IDisposable:

observers += observer.OnNext;
return Disposable.Create(() => observers -= observer.OnNext);