Qu'est-ce qu'un bon moyen de créer un Observable pour une méthode?

Question

Disons que nous avons une classe:

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

Je voudrais créer une observable des valeurs qui sont produites par la méthode Do . Une façon de le faire serait de créer un événement qui est appelé à partir de Do et utiliser Observable.FromEvent pour créer l'observable. Mais de toute façon, je ne me sens pas bien dans la création d'un événement juste pour le plaisir de la tâche. Y at-il une meilleure façon de le faire?

Answer 1

Matt réponse m'a fait penser à ceci:

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

En général, vous voulez éviter d'utiliser des sujets. Dans mon experiance il est un signe que vous faites quelque chose de mal. Observable.Create ou peut-être générer sont normalement meilleurs ajustements.

Je serais curieux de voir ce que vous essayez de faire en fait pour voir si nous pouvons fournir une meilleure réponse. Lee

Answer 3

Je suppose que vous contrôlez la classe Foo, puisque vous parlez d'ajouter un événement comme une option. Puisque vous possédez la classe, est-il une raison quelconque vous ne pouvez pas définir votre propre implémentation IObservable pour la méthode 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;
    }
}

Votre classe a maintenant une propriété Observable<String> qui fournit un moyen de souscrire aux valeurs renvoyées par la méthode 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.

Je n'ai pas tâté trop dans le cadre réactif, mais je pense que cela est proche de la façon dont vous le faire.

Answer 4

Observable.Generate permet de résoudre votre problème, même si vous n'avez pas besoin d'utiliser la condition et continuez votre échantillon. Ce juste crée et objet et retourne sans cesse le résultat de l'appel à 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
  );

Dans la pratique, vous ne voulez souvent de suivre un certain état et avoir une certaine condition de terminaison. Générer le rend facile.

Answer 5

Je regardais le modèle EventAggregator. Il y a un grand article avec le code exemple qui montre une mise en œuvre avec StructureMap.

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