CODEWITHSUNDEEP
c#eventsnugetinversion-of-control
e_ne
e_ne

Reputation: 8459

Event dispatching library with IoC

In the past I've built a MessageDispatcher component that scans an assembly for types decorated with certain attributes and initializes an instance of each. Then, when any object is fed to the MessageDispatcher instance, every previously initialized instance which contains a method which signature contains the type of the passed object has said method triggered with the specified parameter. For example, in a scenario like:

[Listener]
public class MyListener
{
    MessageDispatcher _dispatcher; //Assigned elsewhere

    [MessageListener]
    public async Task DoSomething(int value)
    {
        var otherValue = await _dispatcher.Next<string>();
        Console.WriteLine($"{value} is {otherValue}.");
    }
}

The following code initializes an instance of the MyListener class, calls DoSomething and prints "7 is okay.":

var listener = new MessageDispatcher(typeof (ListenerAttribute));
listener.Dispatch(7);
listener.Dispatch("okay");

I would like to know if there are any libraries out there that are dedicated to or include a service like such. It has to be able to:

Upvotes: 1

Views: 435

Answers (1)

jgauffin
jgauffin

Reputation: 101130

(as library recommendations is not allowed per the SO rules, here is an attempt to instead answer with an implementation)

You can get that with virtually any IoC. All they need is to be able to register services using an attribute or some other conventional way.

As for the message dispatching. Just create an interface like IMessageHandler<TMessage>. Implement it on all classes that should handle messages.

Example:

public interface IMessageHandler<TMessage>
{
    void Handle(TMessage msg);
}

public class SomeService : IMessageHandler<UserCreated>
{
    //[.. all other methods ..]

    public void Handle(UserCreated msg)
    {
        // ...
    }
}

To publish messages you create a dispatcher. Since you use a container you do not have to make it static. Use your container inside it (service location) to dispatch the messages. Now some peeps might say oohh no, service location is anti-pattern, buhuhuhu. Well no. Not in all cases. In this case it's an implementation details in a class with the specific purpose to identify and invoke other classes.

public interface IMessageDispatcher
{
    void Dispatch<TMessage>(TMessage msg);
}

// The actual implementation differs
// depending on your choice of container.
public class ContainerBasedMessageDispatcher : IMessageDispatcher
{
    Container _container;

    public ContainerBasedMessageDispatcher(Container container)
    {
        _container = container;
    }
    public void Dispatch<TMessage>(TMessage message)
    {
        using (var scope = container.BeginLifetimeScope())
        {
            var handlers = scope.Resolve<IEnumerable<IMessageHandler<TMessage>>();
            foreach (var handler in handlers)
            {
                handler.Handle(message);
            }
        }
    }
}

The code is written directly in SO. So it might not work as-is. But hopefully it's given you an idea how to achieve what you want.

Usage:

public class UserService
{
   IMessageDispatcher _dispatcher;

   public UserService(IMessageDispatcher dispatcher)
   {
       _dispatcher = dispatcher;
   }

   public void Create(User user)
   {
       //[...]


       _dispatcher.Dispatch(new UserCreated(user.Id));
   }
}

this do however not dynamically allow you to subscribe on what you want. If just ignoring unwanted messages is not feasible. Then this answer is not for you.

Upvotes: 4

Related Questions