C#中介器中的强类型消息处理程序

Question

I'm currently having a problem implementing a solution for inter-object communication in my current project. I decided to try out an object like the mediator pattern, where objects communicate with each other using messages via a broadcast to the mediator. The mediator then sends the message to objects that have specifically listened to the message being broadcast.

Previous mediator objects I've used relied on holding containers to handlers only handling a base message, forcing listeners to cast the messages before they could handle them. I thought I could get by this by having collections of handlers themselves in a keyed collection according to some arbitrary type. By doing this, I'm hoping to avoid any kind of casting a listener has to do to respond to a message.

The trouble is, I can't seem to follow how to get an object that allows others to Register for a strongly-typed message to maintain a single collection of different kinds of strongly-typed message handlers.

Ideally, I'd like the public-facing interface to look as follows:

class Mediator
{
    private Dictionary<Type, ???> handlers; // how to I retain the strongly-typed handler


    public void RegisterForBroadcast<T>(Action<T> handler) where T : IMessage
    {
        // how can I turn the strongly-typed handler into something I can use?
    }

    public void UnregisterFromBroadcast<T>(Action<T> handler) where T : IMessage
    {
    }

    public void Broadcast<T>(T message) where T : IMessage
    {
        // how do I get the collection of handlers from where it's stored and use it?
    }
}

class Receiver
{
     private Mediator mediator; 

     public Receiver()
     { 
          mediator = GetMediator();
          mediator.RegisterForBroadcast<SpecificMessage>(MessageHandler);
     }

     private void MessageHandler(SpecificMessage msg)
     {
          CustomData data = msg.GetCustomData();
     }
}

class BroadcastingObject
{
     private Mediator mediator;
     private SpecificData data;

     public BroadcastingObject()
     {
          mediator = GetMediator();
          specificData = GetSpecificData();
     }

     public void TimeToBroadcast()
     {
          mediator.Broadcast<SpecificMessage>(new SpecificMessage(specificData));
     }
}

Is it possible with this design to have the strongly-typed message handling that I want? If so, how do I do it?

Edit - added code to describe how I'd want a sender and receiver object to interact with the methods.

Answer 1

Probably the best way would be to look at how Mediatr implements the pattern since it's the most popular C# library for the Mediator pattern/in app messaging.

https://github.com/jbogard/MediatR/blob/master/src/MediatR/Mediator.cs

In short, it holds a list of wrapper objects of "NotificationHandlerWrapperImpl". But it holds them in a list of objects (So that you get around Action vs Action vs Action casting issues).

private static readonly ConcurrentDictionary<Type, object> _requestHandlers = new ConcurrentDictionary<Type, object>();

The actual implementation of that wrapper is fairly simple : https://github.com/jbogard/MediatR/blob/e8833143c0742bdf72a6c6f104ef1dfadb59bf42/src/MediatR/Internal/NotificationHandlerWrapper.cs

It basically uses the service locator pattern to get instances of IHandler :

var handlers = serviceFactory
    .GetInstances<INotificationHandler<TNotification>>()
    .Select(x => new Func<INotification, CancellationToken, Task>((theNotification, theToken) => x.Handle((TNotification)theNotification, theToken)));

Mediatr is actually quite simple and I highly recommend downloading the source code if you want to pick and prod bits out to build your own. Otherwise, just use Mediatr itself as for most cases, it's going to be sufficient and you don't need to roll your own! Quick guide to getting up and running here : https://dotnetcoretutorials.com/2019/04/30/the-mediator-pattern-part-3-mediatr-library/