Was ist ein guter Weg, um eine beobachtbare für ein Verfahren zu schaffen?

Question

Lassen Sie uns sagen, wir haben eine Klasse:

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

Ich möchte eine beobachtbare von Werten erstellen, die von Do Verfahren hergestellt werden. Eine Möglichkeit, dies zu tun wäre, um ein Ereignis zu erstellen, die von Do genannt wird und Verwendung Observable.FromEvent , um die beobachtbaren zu erstellen. Aber irgendwie fühle ich mich nicht gut über die Schaffung eines Ereignisses nur aus Gründen der Aufgabe. Gibt es einen besseren Weg, es zu tun?

Answer 1

Matts Antwort hat mich darüber nachgedacht:

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

Im Allgemeinen wollen Sie mit Themen zu vermeiden. In meinem experiance ist es ein Zeichen Sie etwas falsch machen. Observable.Create oder vielleicht generieren sind in der Regel besser passt.

würde mich interessieren zu sehen, was Sie tatsächlich versuchen, um zu sehen zu tun, wenn wir eine bessere Antwort geben kann. Lee

Answer 3

Ich gehe davon aus Sie die Foo-Klasse steuern, da Sie sprechen über ein Ereignis, um es als eine Option hinzufügen. Da Sie die Klasse besitzen, gibt es keinen Grund Sie nicht Ihre eigene IObservable Implementierung für die Do-Methode definieren können?

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;
    }
}

Ihre Klasse hat jetzt eine Observable<String> Eigenschaft, die einen Weg zu den Werten aus der Do-Methode zurück abonnieren sieht vor:

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.

Ich habe nicht zu viel in den reaktiven Rahmen ausprobiert, aber ich denke, das ist in der Nähe, wie Sie dies tun würden.

Answer 4

Observable.Generate löst Ihr Problem, obwohl Sie nicht brauchen, um den Zustand zu verwenden, und die weiterhin für Ihre Probe. Das ist einfach erstellt und Objekt und gibt kontinuierlich das Ergebnis des Aufrufs zu 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 der Praxis Sie oft tun wollen einige Zustand verfolgen und einige Abbruchbedingung haben. Generieren Sie macht es einfach.

Answer 5

würde ich am Eventaggregator Modell aussehen. Es gibt einen großen Artikel mit Beispielcode, der zeigt eine Implementierung mit StructureMap.

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