Skip to content


Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

Latest commit


Git stats


Failed to load latest commit information.

NuGet Build status


An implementation of the Event Aggregator Pattern.

Supports .Net Core (.Net 4.5 & netstandard1.0) running on:

  • .Net Core
  • .Net Framework 4.5 and above
  • Mono & Xamarin
  • UWP
  • Windows 8.0
  • Windows Phone 8.1
  • Windows Phone Seilverlight 8.0
If you enjoy what I build then please Buy Me A Coffee :-)

Usage example:

Start by creating an instance of the hub:

IMessageHub hub = new MessageHub();

You can now use the hub to subscribe to any publication of a given type:

Guid token = hub.Subscribe<Person>(p => Console.WriteLine($"Id is: {p.Id}"));
// or    
Action<string> action = message => Console.WriteLine($"Message is: {message}");
Guid anotherToken = hub.Subscribe(action);

You can then use the token to do:

hub.IsSubscribed(token); // returns true
hub.IsSubscribed(token); // returns false

Or you can clear all subscriptions by:


Publication is as easy as:

hub.Publish(new Person { Id = "Foo" });
hub.Publish("An important message");

Error handling:

The hub catches any exception thrown at the time of publication and exposes them via:

hub.RegisterGlobalErrorHandler((token, e) => Console.WriteLine($"Error Publishing, Token: {token} | Exception: {e}"));

Global handler:

The hub allows the registration of a single handler which will receive every message published by the hub. This can be useful in scenarios where every message published should be logged or audited.

hub.RegisterGlobalHandler((type, eventObject) => Console.WriteLine($"Type: {type} - Event: {eventObject}"));

Event throttling:

The hub allows each subscriber to throttle the rate at which it receives the events:

hub.Subscribe<string>(msg => Console.WriteLine($"Message is: {msg}"), TimeSpan.FromSeconds(1));

In the above example, if the subscriber receives more than one message within 1 second of another, it drops them.

Inheritance support:

The hub supports inheritance by allowing to subscribe to a base class or an interface and receiving all the publications of types that inherit or implement the subscribed type. For example, given:

public class Order {}
public class NewOrder : Order{}
public class BigOrder : Order{}

A subscriber registering against Ordrer will also receive events of type NewOrder and BigOrder.

More details HERE