Architecture for a Service with Multiple Clients using DispatcherObject

/// <summary>
///     Interface defining the IEventAggregatorService interface.
/// </summary>
public interface IEventAggregatorService
{
    /// <summary>
    ///     Subscription method. Registeres an object to receive events.
    /// </summary>
    /// <param name="subscriber">
    ///     The object that should consume events. The object must implement
    ///     the interface <see cref="IHandle{T}" /> for each type of message to listen to.
    /// </param>
    void Subscribe(object subscriber);

    /// <summary>
    ///     Unsubsribes from message notification.
    /// </summary>
    /// <param name="subscriber">The subscriber, that should no longer receive events.</param>
    void Unsubscribe(object subscriber);

    /// <summary>
    ///     Publish an event synchronously to subscribers.
    /// </summary>
    /// <typeparam name="T">The type of the event to be published.</typeparam>
    /// <param name="message">The event to publish.</param>
    void Publish<T>(T message);

    /// <summary>
    ///     Publish an event asynchronously to subscribers.
    /// </summary>
    /// <typeparam name="T">The type of the event to be published.</typeparam>
    /// <param name="message">The event to publish.</param>
    Task PublishAsync<T>(T message);
}

/// <summary>
///     Event aggregator to publish typed events. Implements <see cref="IEventAggregatorService" />.
/// </summary>
[SuppressMessage("ReSharper", "PossibleNullReferenceException")]
public sealed class EventAggregatorService : IEventAggregatorService
{
    internal readonly ILogger Logger;

    /// <summary>
    /// Constructor
    /// </summary>
    /// <param name="logger">The internally used <see cref="ILogger"/></param>
    public EventAggregatorService(ILogger logger = null)
    {
        Logger = logger;
    }

    /// <summary>
    ///     The list of registered event subscribers.
    /// </summary>
    internal readonly List<WeakReference> Subscribers = new List<WeakReference>();

    /// <summary>
    ///     A lock that protects <see cref="Subscribers" /> while in use.
    /// </summary>
    private readonly object _subscribersLock = new object();

    /// <summary>
    ///     Subscription method. Registeres an object to receive events.
    /// </summary>
    /// <param name="subscriber">
    ///     The object that should consume events. The object must implement
    ///     the interface <see cref="IHandle{T}" /> for each type of message to listen to.
    /// </param>
    public void Subscribe(object subscriber)
    {
        Logger?.Trace(LoggingEventId.EventAggregatorServiceSubscribe, "Subscribing {0}", subscriber.GetType().Name);
        if (!subscriber.GetType().GetInterfaces()
            .Any(x => x.IsGenericType &&
                      (x.GetGenericTypeDefinition() == typeof(IHandle<>) ||
                       x.GetGenericTypeDefinition() == typeof(IHandleAsync<>))))
        {
            Logger?.Error(LoggingEventId.EventAggregatorServiceSubscribe, "Subscriber {0} does not implement any handlers", subscriber.GetType().Name);
            throw new ArgumentException("Subscriber does not implement any handlers");
        }

        lock (_subscribersLock)
        {
            if (Subscribers.All(w => w.Target != subscriber))
            {
                Subscribers.Add(new WeakReference(subscriber));
                Logger?.Trace(LoggingEventId.EventAggregatorServiceSubscribe, "{0} subscribed", GetType().Name);
            }
            else Logger?.Error(LoggingEventId.EventAggregatorServiceSubscribe, "{0} already subscribed", subscriber.GetType().Name);
        }
    }

    /// <summary>
    ///     Unsubsribes from message notification.
    /// </summary>
    /// <param name="subscriber">The subscriber, that should no longer receive events.</param>
    public void Unsubscribe(object subscriber)
    {
        Logger?.Trace(LoggingEventId.EventAggregatorServiceUnubscribe, "Unsubscribing {0}", subscriber.GetType().Name);
        if (!subscriber.GetType().GetInterfaces()
            .Any(x => x.IsGenericType &&
                      (x.GetGenericTypeDefinition() == typeof(IHandle<>) ||
                       x.GetGenericTypeDefinition() == typeof(IHandleAsync<>))))
        {
            Logger?.Error(LoggingEventId.EventAggregatorServiceUnubscribe, "Subscriber {0} does not implement any handlers", subscriber.GetType().Name);
            throw new ArgumentException("Subscriber does not implement any handlers");
        }

        lock (_subscribersLock)
        {
            if (Subscribers.Any(w => w.Target == subscriber))
            {
                Subscribers.Remove(Subscribers.First(w => w.Target == subscriber));
                Logger?.Trace(LoggingEventId.EventAggregatorServiceUnubscribe, "{0} unsubscribed", GetType().Name);
            }
            else Logger?.Error(LoggingEventId.EventAggregatorServiceUnubscribe, "{0} not subscribed", subscriber.GetType().Name);
        }
    }

    /// <summary>
    ///     Publish an event synchronously to subscribers.
    /// </summary>
    /// <typeparam name="T">The type of the event to be published.</typeparam>
    /// <param name="message">The event to publish.</param>
    public void Publish<T>(T message)
    {
        Logger?.Trace(LoggingEventId.EventAggregatorServicePublish, "Publishing {0} synchronously", typeof(T).Name);
        var subscribers = GetSubsribersForMessageType<T>();
        subscribers.ToList()
            .ForEach(subscriber =>
            {
                try
                {
                    (subscriber as IHandle<T>)?.Handle(message);
                    (subscriber as IHandleAsync<T>)?.HandleAsync(message).Wait();
                }
                catch (Exception error)
                {
                    Logger?.Error(LoggingEventId.EventAggregatorServicePublish, error,"Error publishing {0} synchronously", typeof(T).Name);
                }
            });
    }

    /// <summary>
    ///     Publish an event asynchronously to subscribers.
    /// </summary>
    /// <typeparam name="T">The type of the event to be published.</typeparam>
    /// <param name="message">The event to publish.</param>
    public Task PublishAsync<T>(T message)
    {
        Logger?.Trace(LoggingEventId.EventAggregatorServicePublishAsync, "Publishing {0} asynchronously", typeof(T).Name);
        var subscribers = GetSubsribersForMessageType<T>();
        Task result = null;
        try
        {
            result = Task.WhenAll(subscribers
                .Select(x => new
                {
                    Handler = x as IHandle<T>,
                    AsyncHandler = x as IHandleAsync<T>
                })
                .Select(
                    x =>
                        x.Handler != null
                            ? Task.Run(() => x.Handler.Handle(message))
                            : x.AsyncHandler.HandleAsync(message)));
        }
        catch (Exception error)
        {
            Logger?.Error(LoggingEventId.EventAggregatorServicePublishAsync, error, "Error publishing {0} asynchronously", typeof(T).Name);
        }
        return result;
    }

    internal object[] GetSubsribersForMessageType<T>()
    {
        lock (_subscribersLock)
        {
            Subscribers.RemoveAll(w => w.Target == null);
            return (from s in Subscribers
                    let x = s.Target
                    where x != null &&
                          x.GetType()
                              .GetInterfaces()
                              .Any(i => i.IsAssignableFrom(typeof(IHandle<T>)) ||
                                        i.IsAssignableFrom(typeof(IHandleAsync<T>)))
                    select x).ToArray();
        }
    }
}

/// <summary>
///     Interface defining handler for a given type of event. Subscribers must implement this interface a number
///     of times - once for each type of event to consume. Besides implementing this interface for each type of
///     event, the subscriber must notify the event aggregator about its intention to receive messages by invoking
///     <see cref="IEventAggregatorService.Subscribe" />
/// </summary>
/// <typeparam name="T">The type of event to consume</typeparam>
public interface IHandle<in T>
{
    /// <summary>
    ///     Handler method. This defines the method (sink) that handles a given type of event. Must not throw exceptions.
    /// </summary>
    /// <param name="message">The event/message published by the event aggregator.</param>
    void Handle(T message);
}

/// <summary>
///     Interface defining handler for a given type of event. Subscribers must implement this interface a number
///     of times - once for each type of event to consume. Besides implementing this interface for each type of
///     event, the subscriber must notify the event aggregator about its intention to receive messages by invoking
///     <see cref="IEventAggregatorService.Subscribe" />
/// </summary>
/// <typeparam name="T">The type of event to consume</typeparam>
public interface IHandleAsync<in T>
{
    /// <summary>
    ///     Handler method. This defines the method (sink) that handles a given type of event. Must not throw exceptions
    /// </summary>
    /// <param name="message">The event/message published by the event aggregator.</param>
    Task HandleAsync(T message);
}