Creating interfaces for a messaging system

[SLH]

Ok, i've been going round in circles for a few days now.
What i want is to allow classes in my program to listen for messages, as well as send messages out. These messages could be sent over the network, saved to disk or delt with instantly etc.

In any program there may be several message dispatchers (handling multiple message types), several message listeners (listening for multiple message types).

The overall problem i'm coming across is how to define all the interfaces, classes and extension methods to facilitate this.

Here is the code i've got so far:

public class Message
    {
        public object Sender { get; set; }
        public string Name { get; set; }
        public Message(object sender, string name) { Sender = sender; Name = name; }
    }
    public class GUIMessage : Message
    {
        public string Control { get; set; }
        public GUIMessage(object sender, string name, string control)
            : base(sender, name) { Control = control; }
    }
 
    public class MouseMessage : Message
    {
        public Point Pos { get; set; }
        public MouseMessage(object sender, string name, Point pos)
            : base(sender, name) { Pos = pos; }
    }
 
 
 
public interface IMessageDispatcher
    {
        List<IMessageListener<Message>> Listeners { get; set; }
        List<Message> Messages { get; set; }
    }
 
    public static class MessageDispatcherExtensionMethods
    {
        public static void PostMessage(this IMessageDispatcher MessageDispatcher, Message Msg)
        {
            MessageDispatcher.Messages.Add(Msg);
        }
 
        public static void DispatchMessages<TArgs>(this IMessageDispatcher MessageDispatcher) where TArgs : Message
        {
            foreach (TArgs Msg in MessageDispatcher.Messages)
            {
                foreach (IMessageListener<TArgs> Listener in MessageDispatcher.Listeners)
                {
                    Listener.HandleMessage(Msg.Sender, Msg);
                }
            }
            MessageDispatcher.Messages.Clear();
        }
 
        public static void AddListener<TArgs>(this IMessageDispatcher MessageDispatcher, IMessageListener<TArgs> MessageListener) where TArgs : Message
        {
            MessageDispatcher.Listeners.Add(MessageListener);
        }
    }
 
 
 
public interface IMessageListener<TArgs> where TArgs : Message
    {
        void HandleMessage(object sender, TArgs Args);
    }

The problem is that it seems i can't have a message dispatcher that contains a list of all messages since c# doesn't support covarence i.e. i can't add an IMessageListener<GUIMessage> to my List<IMessageListener<Message>> Listeners, even though GUIMessage is derived from Message.

Am i going to have to make the IMessageDispatcher generic too, and have my classes impliment each one seperately or is there a more elegent solution?

Cheers for any help, i've been banging my head against the wall for a while now!