C# 方法可观察

Question

I have a method that is called whenever something happens. It can be called any number of times. Then method returns a Task. Basically I want to setup an "obserable" for when ever this method is called. I have no control over the method being called. The method that is called is virtual so I can override it an see that it gets called. But I would rather setup an "observable". So I have something like

class Foo
{
  void Bar()
}

Again I have no control over Foo but I have an instance of it.

var instanceofFoo = new Foo();

I want to setup an "observable" that will be triggered anytime that instanceOfFoo.Bar is called.

The reason that I want an "observable" is because I don't want to have to setup the "observer" again for possibly the next call. I am coding in C# and I looked at IObservable<T> and IObserver<T> but there it specifically indicated that the "provider" had to implement IObservable<T> . Since I don't have control over the provider (in this case the instance of Foo) I cannot use this. I looked at Rx.NET but was unable to glean from the examples something that fit this situation. To further complicate things assume that the instance of Foo is a dependency of another class like

class FooService
{
    public bool wasCalled { get; set; }
    public FooService(Foo f)
    {
       // TODO: Setup code to trigger when f.Bar() is called
    }
}

This setup would need to be able to be cleanly torn down so that there are no dangling "subscribers".

So the flow would be something like this

1. var foo = new Foo();
2. var fooService = new FooService(foo);
3. foo.Bar();
4. Assert.IsTrue(fooService.wasCalled);

Ideas?

Answer 1

I'm not sure why you focus on "observables", but C# has a system for subscriber/publisher type of interaction already, namely events .

You can use the Proxy pattern combined with inheritance to achieve what you want:

class FooEventProxy : Foo
{
    public event EventHandler BarCall;

    /*
     *   Retype all constructors of Foo here and delegate them to base.
     */

    public override void Bar()
    {
        OnBarCall(new EventHandler());
        base.Bar();
    }

    protected virtual void OnBarCall(EventHandler e)
    {
        EventHandler event = BarCall;

        if (event != null)
        {
            event(this, e);
        }
    }
}

This is assuming that you control the creation of Foo and can just force all places it's created to use FooEventProxy instead.

If you can't then you just found out the reason for keeping all your creation logic in factories and the situation is a bit more complicated. If you can access all the arguments of Foo that it was instantiated with you can probably just copy them over to the new instance of FooEventProxy . If you can't then we're in a conundrum: you want to replace an argument of type Foo with FooEventProxy , but you can't ensure that the internal state of the argument will be correctly transferred into the new instance. You can't just route the virtual method calls to the wrapped instance, since the non-virtual methods can still be called and will not work correctly - violation of the Liskov principle. So you need to either copy the internal state of Foo exactly into FooEventProxy using massive reflection voodoo or, well, you're out of luck and you've just found out the reason for depending on interfaces/abstracts and not concrete classes.

I don't know how to copy over all base class data from an existing instance to a new instance of a derived type off the top of my head, so if you really think that's what you want, please ask another question specifically for that.

Answer 2

Sounds like this is just for unit testing. I can provide you with two answers, depending on your constraints.

If you are able to modify the code, then the best (and most SOLID ) approach is to depend on an interface instead of a concrete class, wrapping if necessary. Then in your unit tests you can substitute a method call that calls the original method but also does something else (eg logs it).

interface IFoo
{
    void Bar();
}

class Foo : IFoo
{
    public void Bar() { }
}

Then in your test code:

class FooShim : IFoo
{
    protected readonly Foo _foo;
    protected readonly Action _action;

    public FooShim(Foo foo, Action action) 
    {
         _foo = foo;
         _action = action;
    }

    public Bar()
    {
        action();
        _foo.Bar();
    }
}


//Arrange
bool wasCalled = false;
var foo = new FooShim(new Foo(), () => wasCalled = true);
var fooService = new FooService(foo);

//Act
fooService.DoSomethingThatCallsFoo();

//Assert
Assert.IsTrue(wasCalled);

If you are not able to modify the code, you can do something similar, but you will need a special framework like TypeMock . TypeMock takes advantage of .NET CLR internals to allow you to intercept and replace method calls.

Isolate.WhenCalled( () => foo.Bar()).WillBeReplacedWith( () => wasCalled = true );