Question

I have written a simple mediator for my WPF application (which is a derivative of the code found here).

public class Messenger
{
    private IDictionary<Type, IList<MessageObserver>> observers;

    public Messenger()
    {
        observers = new Dictionary<Type, IList<MessageObserver>>();
    }

    public IDisposeObserver AddObserver<TMessageType>(Action<TMessageType> handler) 
        where TMessageType : Message { }

    protected abstract void RemoveObserver<TMessageType>(Action<TMessageType> handler) 
        where TMessageType : Message { }

    public abstract void PostMessage<TMessageType>(TMessageType message) 
        where TMessageType : Message { }
}

Message is just an empty class that provides a base class for all messages that are posted via the Messenger. The idea is you would derive from this class to create a specific message class with relevant data (a bit like EventArgs).

Where my implementation differs is in the way I want to remove observers. I want to be able to specify when they should be removed in a declarative way, along the lines of:

MessengerInstance.AddObserver<LoginMessage>(HandleLogin)
    .RemoveObserverWhen(message => message.LoginResult == LoginResult.Successful);

The RemoveObserverWhen method takes a Predicate<T> where T should be the message type specified in the AddObserver method.

The idea here is you can specify the logic that removes the observer in the same place as registering the observer itself. The Messenger class will then check the predicate after the message handler has been run and remove both the message handler and the removal handler if the predicate evaluates to true.

Each message handler can have any number of removal handlers so I have packaged this up in a class called MessageObserver.

public class MessageObserver : IDisposeObserver
{
    private IList<object> disposalHandlers;

    public MessageObserver(object observer)
    {
        Observer = observer;
        disposalHandlers = new List<object>();
    }

    public object Observer { get; private set; }

    public IList<object> DisposalHandlers
    {
        get { return disposalHandlers; }
    }

    public IDisposeObserver RemoveObserverWhen<T>(Predicate<T> predicate) 
        where T : Message
    {
        disposalHandlers.Add(predicate);
        return this;
    }
}

The MessageObserver implements IDisposeObserver which provides the RemoveObserverWhen method.

public interface IDisposeObserver
{
    IDisposeObserver RemoveObserverWhen<T>(Predicate<T> predicate) 
        where T : Message;
}

The idea here is that an IDisposeObserver instance can be returned so that methods can be chained.

All this works and I have the following code in my viewModel:

MessengerInstance.AddObserver<LoginMessage>(HandleLogin)
    .RemoveObserverWhen<LoginMessage>(message => message.LoginResult == LoginResult.Successful)
    .RemoveObserverWhen<LoginMessage>(SecondDisposalHandler);

The problem I have is that this only works if I specify the generic parameter (LoginMessage in this case) when calling the RemoveObserver method. I would like to be able to call the methods in the way described at the beginning of the post.

I think I need to somehow return a generic IDisposeObserver but if I make this change then the MessageObserver has to be made generic and then I cannot specify the constraints as the Messenger class is non generic.

So my question is, Can my code be updated so that I do not have to specify the message type when calling the RemoveObserverWhen method or do I have to live with my current solution?

Note: I am aware that there are other implementations of this available but I am doing this to help my understanding of object oriented design principles and generics in c# so please do not point me in the direction of other implementations.

Answer 1

I think I need to somehow return a generic IDisposeObserver but if I make this change then the MessageObserver has to be made generic and then I cannot specify the constraints as the Messenger class is non generic.

You probably want to have a non-generic MessageObserver base class which contains all the type-neutral parts, and then a generic one which implements a generic IDisposeObserver<T>. You can then change AddObserver to return the generic IDisposeObserver<T>, but keep the dictionary within Messenger as IDictionary<Type, IList<MessageObserver>>. So just to be clear, you’d have:

public interface IDisposeObserver<T>
{
    IDisposeObserver<T> RemoveObserverWhen(Predicate<T> predicate) 
        where T : Message;
}

public abstract class MessageObserver { ... }

public class MessageObserver<T> : MessageObserver, IDisposeObserver<T> { ... }

The problem then comes when you have to execute the IDiposeObserver<T>.RemoveObserverWhen method – you may well need to just cast each item within the dictionary’s list to IObserver<T>. You’d know the T at that point, and you’d know that you’d populated the list appropriately.

Of course, if that’s the only thing you’re going to do with the observers, you could just keep an IDictionary<Type, IList<object>> instead, and not bother having the two different MessageObserver classes. It really depends on whether you get any value out of the non-generic one.