come implementare un evento utilizzando reattivi estensioni

Question

Le estensioni reattive consentono di iscriversi facilmente ad un evento utilizzando Observable.FromEventPattern, ma non riesco a trovare nulla su come si potrebbe implementare un evento quando si dispone di un IObservable.

La mia situazione è questa: ho bisogno di implementare un'interfaccia che contiene un evento. Questo evento dovrebbe essere chiamato ogni volta che cambia un certo valore dell'oggetto, e per motivi di sicurezza del thread devo chiamare questo evento su un certo SynchronizationContext. Devo anche chiamare ogni gestore di eventi con il valore corrente alla registrazione.

public interface IFooWatcher 
{ 
    event FooChangedHandler FooChanged; 
} 

Ottenere un osservabile che fa quello che voglio è piuttosto facile con Rx utilizzando BehaviorSubject:

public class FooWatcher 
{ 
    private readonly BehaviorSubject<Foo> m_subject; 
    private readonly IObservable<Foo> m_observable; 

    public FooWatcher(SynchronizationContext synchronizationContext, Foo initialValue) 
    { 
     m_subject = new BehaviorSubject<Foo>(initialValue); 
     m_observable = m_subject 
      .DistinctUntilChanged() 
      .ObserveOn(synchronizationContext); 
    } 

    public event FooChangedHandler FooChanged 
    { 
     add { /* ??? */ } 
     remove { /* ??? */ } 
    } 
} 

Ora sto cercando un modo semplice per avere le add e remove funzioni iscriversi e cancellarsi dalla passata FooChangedHandler come Observer<Foo> su m_observable. Il mio attuale implementazione è simile a questo:

add 
    { 
     lock (m_lock) 
     { 
      IDisposable disp = m_observable.Subscribe(value); 
      m_registeredObservers.Add(
       new KeyValuePair<FooChangedHandler, IDisposable>(
        value, disp)); 
     } 
    } 

    remove 
    { 
     lock (m_lock) 
     { 
      KeyValuePair<FooChangedHandler, IDisposable> observerDisposable = 
       m_registeredObservers 
        .First(pair => object.Equals(pair.Key, value)); 
      m_registeredObservers.Remove(observerDisposable); 
      observerDisposable.Value.Dispose(); 
     } 
    } 

Tuttavia, spero di trovare una soluzione più facile, perché ho bisogno di implementare alcuni di questi eventi (di differenti tipi di gestore). Ho provato a rollare la mia soluzione generica, ma crea alcuni problemi aggiuntivi che devono essere risolti (in particolare, come si lavora genericamente con un delegato che accetta un parametro di T), quindi preferirei trovare una soluzione esistente per i bridge il divario in questa direzione - proprio come FromEventPattern fa il contrario.

Answer 1

Si potrebbe fare questo:

public event FooChangedHandler FooChanged 
{ 
    add { m_observable.ToEvent().OnNext += value; } 
    remove { m_observable.ToEvent().OnNext -= value; } 
} 

Tuttavia, sulla rimozione, penso che forse si può solo voler disporre della sottoscrizione ... o forse ottenere l'azione da ToEvent() e negozio che, come un membro. Non testato.

MODIFICA: Sarà necessario utilizzare Azione invece di un delegato FooChangedHandler, tuttavia.

MODIFICA 2: Ecco una versione testata. Suppongo che tu debba usare FooChangedHandler, comunque, dato che hai un gruppo di questi handler preesistenti?

void Main() 
{ 
    IObservable<Foo> foos = new [] { new Foo { X = 1 }, new Foo { X = 2 } }.ToObservable(); 
    var watcher = new FooWatcher(SynchronizationContext.Current, new Foo { X = 12 }); 
    watcher.FooChanged += o => o.X.Dump(); 
    foos.Subscribe(watcher.Subject.OnNext); 
} 

// Define other methods and classes here 

//public delegate void FooChangedHandler(Foo foo); 
public interface IFooWatcher 
{ 
    event Action<Foo> FooChanged; 
} 

public class Foo { 
    public int X { get; set; } 
} 
public class FooWatcher 
{ 

    private readonly BehaviorSubject<Foo> m_subject; 
    public BehaviorSubject<Foo> Subject { get { return m_subject; } } 
    private readonly IObservable<Foo> m_observable; 

    public FooWatcher(SynchronizationContext synchronizationContext, Foo initialValue) 
    { 
     m_subject = new BehaviorSubject<Foo>(initialValue); 

     m_observable = m_subject 
      .DistinctUntilChanged(); 
    } 

    public event Action<Foo> FooChanged 
    { 
     add { m_observable.ToEvent().OnNext += value; } 
     remove { m_observable.ToEvent().OnNext -= value; } 
    } 
} 

Answer 2

Dato che si stanno già miscelando i confini tra codice reattivo e codice più normale, è possibile eseguire una versione meno reattiva. Per iniziare è sufficiente dichiarare un normale modello evento

public event FooChangedHandler FooChanged; 

protected void OnFooChanged(Foo) 
{ 
    var temp = FooChanged; 
    if (temp != null) 
    { 
    temp(new FooChangedEventArgs(Foo)); 
    } 
} 

e poi semplicemente collegare il osservabile ad esso nel costruttore

m_Observable.Subscribe(foo => OnFooChanged(foo)); 

Non è molto Rx ma è incredibilmente semplice.