Comment créer un IObservable qui émet lors d'un appel de méthode, sans utiliser de Sujets ou d'événements .NET?

Question

Comment faire passer ce test sans utiliser la classe Subject ou .NET events?

[TestClass] 
public class ObservableTests 
{ 
    private readonly Subject<Unit> _subject = new Subject<Unit>(); 

    [TestMethod] 
    public void ObservesMethodCall() 
    { 
     var eventCount = 0; 
     IObservable<Unit> observable = _subject.AsObservable(); 
     observable.Subscribe(u => eventCount++); 

     Assert.AreEqual(0, eventCount); 
     Foo(); 
     Assert.AreEqual(1, eventCount); 
    } 

    private void Foo() 
    { 
     _subject.OnNext(Unit.Default); 
    } 
} 

Je veux éviter d'utiliser subjects comme they are not recommended. Je ne veux pas utiliser les événements .NET lorsque RxNet les remplace.

questions connexes:

Firing an event every time a new method is called
Il suppose que nous ne pouvons pas modifier la méthode appelée.

How to create Observable that emits every time a member variable is updated (onCompleted never called)
Utilise des sujets.

Is there a way to create an observable sequence triggered by method calls without using Subject?
États Les sujets sont la voie à suivre. Cependant, je veux toujours apprendre comment le faire sans Sujets.

IObserver and IObservable in C# for Observer vs Delegates, Events
Indique comment résoudre le problème en mettant en œuvre la coutume IObservable

Answer 1

Cela pourrait être un peu comme couper les cheveux, mais cela fonctionne sans avoir besoin d'un sujet:

[TestClass] 
public class ObservaleTests 
{ 
    private Action _action = null; 

    [TestMethod] 
    public void ObservesMethodCall() 
    { 
     var eventCount = 0; 

     IObservable<Unit> observable = 
      Observable.FromEvent(a => _action += a, a => _action -= a); 

     observable.Subscribe(u => eventCount++); 

     Assert.AreEqual(0, eventCount); 
     Foo(); 
     Assert.AreEqual(1, eventCount); 
    } 

    private void Foo() 
    { 
     _action(); 
    } 
} 

Answer 2

En bref, vous voulez déclencher un observable de manière procédurale, mais sans utiliser de sujets ou d'événements. Vous pouvez utiliser un délégué personnalisé (réponse de @ Enigmativity), et vous pouvez également implémenter IObservable personnalisé (essentiellement en réinventant des sujets).

Je vais contester le principe cependant: Utilisez un sujet. Ils ne sont pas toujours recommandés, mais ils conviennent à votre problème artificiel tel que présenté. La plus grande question que vous devriez poser cependant est pourquoi vous voulez déclencher une observable procéduralement: Le but entier de System.Reactive est que vous pouvez juste vous inquiéter d'un côté d'un message: Soit le récepteur (observable) ou l'expéditeur (observateur). Vous essayez de faire les deux, ce qui est un sujet. Le problème avec Subjects n'est pas une sorte de détail d'implémentation, ou de dogme (Subjects bad, Observables good), c'est que le but est simplement de se concentrer sur la réception des messages, pas sur l'envoi et la réception.