using System;

using System.Threading;

using System.Threading.Tasks;

using System.Reflection;

using MediatR;

using Autofac;

using Autofac.Extensions.DependencyInjection;

using Microsoft.Extensions.DependencyInjection;

​

//==========================================================================================================

//=================================   CONTRACTS   ==========================================================

//==========================================================================================================

​

// My custom domain event interface totally depleted for sake of semplicity

public interface IEvent{}

​

​

// My custom notification wrapping the event

public interface IEventNotification<TEvent> : INotification

    where TEvent : IEvent

{

    TEvent Event { get; init; }

}

​

// A generic implementation of the MediatR notification. This will be instanciated with the appropriate generic argument before publishing.

public class EventNotification<TEvent> : IEventNotification<TEvent>

    where TEvent : IEvent

{

    public EventNotification(TEvent myEvent)

    {

        Event = myEvent;

    }

​

    public TEvent Event { get; init; }

}

​

// The custom Notification Handler.

// I'd like to simply declare my handlers and get them called when the corresponding event is raised. See usage below.

public interface IEventNotificationHandler<TEvent> : INotificationHandler<IEventNotification<TEvent>>

        where TEvent : IEvent

{

}

​

​

//==========================================================================================================

//=================================   ACTUAL USAGE EXAMPLE =================================================

//==========================================================================================================

​

// An event declaration.

public class TestEvent : IEvent

{

}

​

// The first handler for the test event

public class FirstEventNotificationHandler : IEventNotificationHandler<TestEvent>

{

    public Task Handle(IEventNotification<TestEvent> notification, CancellationToken cancellationToken)

    {

        Console.WriteLine("First notification handler");

        return Task.CompletedTask;

    }

}

​

// A second handler for the same test event

public class SecondEventNotificationHandler : IEventNotificationHandler<TestEvent>

{

    public Task Handle(IEventNotification<TestEvent> notification, CancellationToken cancellationToken)

    {

        Console.WriteLine("Second notification handler");

        return Task.CompletedTask;

    }

}

​

​

//==========================================================================================================

//================================= MY CUSTOM NOTIFICATION HANDLER DECORATOR ===============================

//==========================================================================================================

​

public class CustomNotificationHandlerDecorator<TDomainEvent> : IEventNotificationHandler<TDomainEvent>

    where TDomainEvent : IEvent

{

    private readonly INotificationHandler<IEventNotification<TDomainEvent>> _decorated;

​

    public CustomNotificationHandlerDecorator(IEventNotificationHandler<TDomainEvent> decorated)

    {

        _decorated = decorated;

    }

​

    public Task Handle(IEventNotification<TDomainEvent> notification, CancellationToken cancellationToken)

    {

        Console.WriteLine("I am the custom decorator!");

        _decorated.Handle(notification, cancellationToken);

        Console.WriteLine("Decorator job completed\n");

        return Task.CompletedTask;

    }

}

​

​

//==========================================================================================================

//================================= EXAMPLE APPICATION TO RAISE THE TEST EVENT =============================

//==========================================================================================================

​

class Application

{

    protected readonly IPublisher _mediatr;

​

    public Application(IPublisher mediatr)

    {

        _mediatr = mediatr;

    }

​

    public void Run()

    {

        Console.WriteLine("Publishing the test event...\n");

        _mediatr.Publish(new EventNotification<TestEvent>(new TestEvent()));

        Console.WriteLine("All done.");

    }

}

​

​

//==========================================================================================================

//=================================   ENTRY POINT AND MEDIATR CONFIGURATION ================================

//==========================================================================================================

public class Program

{

    private static IContainer CompositionRoot()

    {

        // code as per https://github.com/jbogard/MediatR/blob/master/samples/MediatR.Examples.Autofac/Program.cs with slight modifications

        var builder = new ContainerBuilder();

        builder.RegisterType<Application>();

        builder.RegisterAssemblyTypes(typeof(IMediator).GetTypeInfo().Assembly).AsImplementedInterfaces();

        builder.RegisterSource(new Autofac.Features.Variance.ContravariantRegistrationSource());

        var mediatrOpenTypes = new[]

        {

            typeof(INotificationHandler<>)

        };

        foreach (var mediatrOpenType in mediatrOpenTypes)

        {

            builder

                .RegisterAssemblyTypes(typeof(Program).GetTypeInfo().Assembly)

                .AsClosedTypesOf(mediatrOpenType)

                .AsImplementedInterfaces();

        }

        var services = new ServiceCollection();

        builder.Populate(services);

        // Add the cursed custom decorator

        // Comment out this line to get all working (but without decoration...)

        builder.RegisterGenericDecorator(typeof(CustomNotificationHandlerDecorator<>),typeof(INotificationHandler<>));

​

        return builder.Build();

    }

    public static void Main()

    {

        CompositionRoot().Resolve<Application>().Run();

    }

}