Che cosa è un buon modo per creare un 'osservabile per un metodo?

Question

esempio di Let, abbiamo una classe:

public class Foo
{
   public string Do(int param)
   {
   }
}

Mi piacerebbe creare un osservabile di valori che vengono prodotte da Do metodo. Un modo per farlo sarebbe quello di creare un evento che viene chiamato da Do e l'uso Observable.FromEvent per creare l'osservabile. Ma in qualche modo non mi sento bene con la creazione di un evento solo per il gusto del compito. C'è un modo migliore per farlo?

Answer 1

La risposta di Matt mi ha fatto pensare a questo:

public class Foo
{
    private readonly Subject<string> _doValues = new Subject<string>();

    public IObservable<string> DoValues { get { return _doValues; } }

    public string Do(int param)
    {
        var ret = (param * 2).ToString();
        _doValues.OnNext(ret);
        return ret;
    }
}


var foo = new Foo();
foo.DoValues.Subscribe(Console.WriteLine);
foo.Do(2);

Answer 2

In genere si vuole evitare l'uso di soggetti. Nella mia esperienza è un segno che si sta facendo qualcosa di sbagliato. Observable.Create o forse generare sono adatta normalmente migliori.

Mi sarebbe interessato a vedere che cosa si sta effettivamente cercando di fare per vedere se siamo in grado di fornire una risposta migliore. Lee

Answer 3

Sto assumendo di controllare la classe Foo, dal momento che si sta parlando di aggiungere un evento ad essa come un'opzione. Dal momento che il proprietario della classe, c'è qualche ragione per cui non è possibile definire una propria implementazione IObservable per il metodo Do?

public class Foo
{
    DoObservable _doValues = new DoObservable();

    public IObservable<String> DoValues
    {
        return _doValues;
    }

    public string Do(int param)
    {
        string result;
        // whatever
        _doValues.Notify(result);
    }
}

public class DoObservable : IObservable<String>
{
    List<IObserver<String>> _observers = new List<IObserver<String>>();

    public void Notify(string s)
    {
        foreach (var obs in _observers) obs.OnNext(s);
    }

    public IObserver<String> Subscribe(IObserver<String> observer)
    {
        _observers.Add(observer);
        return observer;
    }
}

La classe ora ha una proprietà Observable<String> che fornisce un modo di sottoscrivere i valori restituiti dal metodo Do:

public class StringWriter : IObserver<String>
{
    public void OnNext(string value)
    {
        Console.WriteLine("Do returned " + value);
    }

    // and the other IObserver<String> methods
}

var subscriber = myFooInstance.DoValues.Subscribe(new StringWriter());
// from now on, anytime myFooInstance.Do() is called, the value it 
// returns will be written to the console by the StringWriter observer.

Non ho dilettava troppo nel quadro reattivo, ma credo che questo è vicino a come si dovrebbe fare questo.

Answer 4

Observable.Generate risolve il problema, anche se non è necessario utilizzare la condizione e i continui per il campione. Questo crea solo ed oggetto e continuamente restituisce il risultato della chiamata a DoIt ():

Observable.Generate (
  new Foo(),
  item => true, // in your example, this never terminates
  item => item, // we don't actually do any state transitions
  item => { return item.DoIt(); }  // This is where we emit our value
  );

In pratica, spesso si vuole monitorare uno stato e avere qualche condizione di terminazione. Genera lo rende facile.

Answer 5

Vorrei guardare il modello EventAggregator. C'è un grande articolo con il codice di esempio che mostra un'implementazione con StructureMap.

http://www.codeproject.com/KB/architecture/event_aggregator.aspx