¿Cuál es una buena forma de crear un IObservable para un método?

Question

Digamos, tenemos una clase:

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

Me gustaría crear un observable de los valores que se están produciendo por hacer método. Una forma de hacerlo sería crear un evento al que se llama desde Hacer y usar Observable.FromEvent para crear el evento. Pero de alguna manera no me siento bien con la creación de un evento solo por el bien de la tarea. Hay una mejor manera de hacerlo?

Answer 1

respuesta de Matt me hizo pensar en esto:

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

Supongo que controlas la clase Foo, ya que estás hablando de agregarle un evento como una opción. Como usted es propietario de la clase, ¿hay alguna razón por la que no pueda definir su propia implementación IObservable para el método 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; 
    } 
} 

Su clase tiene ahora una propiedad Observable<String> que proporciona una forma de suscribirse a los valores devueltos por el método 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. 

no he incursionado demasiado en el marco reactiva, pero piensa que esto es parecido a cómo harías esto.

Answer 3

me gustaría ver el modelo EventAggregator. Hay un excelente artículo con código de muestra que muestra una implementación con StructureMap.

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

Answer 4

Generalmente se quiere evitar el uso de los sujetos. En mi experiencia, es una señal de que estás haciendo algo mal. Observable.Create o quizás Generate son normalmente mejores ajustes.

Me gustaría ver lo que realmente está tratando de hacer para ver si podemos proporcionar una mejor respuesta. Lee

Answer 5

Observable.Generate resuelve su problema, aunque no necesita utilizar la condición y continuar para su muestra. Esto sólo crea y continuamente objeto y devuelve el resultado de la llamada 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 
); 

En la práctica, a menudo no desea realizar un seguimiento algún estado y tener alguna condición de terminación. Generar lo hace fácil.