Eml.Mediator 10.1.1

Eml.Mediator

• Has own Visual Studio Addin for easier use.

• Small size.

• Capture Business-use-cases and convert it into a modular, highly testable chunk of codes. One step closer to dissecting & migrating monolithic apps. A combination of Command, Request-Response, Mediator and Abstract Class Factory pattern.

• Provides a common ground for projects with large number of developers.

• .Net5 is now supported.

Features

• ExecuteAsync will always create a new instance of the handler.

• The lifetime of the handler ends as soon as ExecuteAsync is completed.

• If this behavior does not suit your needs, just use dependency injection via the constructor. See example DI signature below:

  IRequestAsyncHandler<TestAsyncRequest, TestResponse> testRequestAsyncHandler
  

A. Usage - Command

    [Fact]
    public async Task Command_ShouldBeCalledOnce()
    {
        var command = new TestAsyncCommand();   //<-Data

        await mediator.ExecuteAsync(command);   //<-Execute

        command.HandlerInvocationCount.ShouldBe(1);
    }

1. Create a command class.

TestAsyncCommand contains the needed data for await mediator.ExecuteAsync(command);.

    public class TestAsyncCommand : ICommandAsync
    {
        public int HandlerInvocationCount { get; set; }

        /// <summary>
        /// This request will be processed by <see cref="TestAsyncCommandHandler"/>.
        /// </summary>
        public TestAsyncCommand()
        {
            HandlerInvocationCount = 0;
        }
    }

2. Create a command handler.

TestAsyncCommandHandler will be auto-discovered and executed by await mediator.ExecuteAsync(command);.

    /// <summary>
    /// DI signature: ICommandAsyncHandler&lt;TestAsyncCommand&gt;.
    /// <inheritdoc cref="ICommandAsyncHandler{TestAsyncCommand}"/>
    /// </summary>
    public class TestAsyncCommandHandler : ICommandAsyncHandler<TestAsyncCommand>
    {
        public async Task ExecuteAsync(TestAsyncCommand commandAsync)
        {
            await Task.Run(() => commandAsync.HandlerInvocationCount++);
        }
    }

B. Usage - Request-Response

    [Fact]
    public async Task Response_ShouldReturnCorrectValue()
    {
        var request = new TestAsyncRequest(Guid.CreateVersion7()); //<-Request

        var response = await mediator.ExecuteAsync(request);       //<-Execute

        response.ResponseToRequestId.ShouldBe(request.Id);         //<-Return Value
    }

1. Create a Request class.

TestAsyncRequest contains the needed data for TestRequestAsyncHandler.

    public class TestAsyncRequest : IRequestAsync<TestAsyncRequest, TestResponse>
    {
        public Guid Id { get; private set; }

        /// <summary>
        /// This request will be processed by <see cref="TestRequestAsyncHandler"/>.
        /// </summary>
        public TestAsyncRequest(Guid id)
        {
            Id = id;
        }
    }

2. Create a Response class.

TestResponse is the return value of await mediator.ExecuteAsync(request);.

    /// <summary>
    /// TestRequestAsyncHandler return value.
    /// </summary>
    public class TestResponse : IResponse
    {
        public Guid ResponseToRequestId { get; }        //<-Return Value

        public TestResponse(Guid responseToRequestId)
        {
            ResponseToRequestId = responseToRequestId;
        }
    }

3. Create a Request handler.

TestRequestAsyncHandler will be auto-discovered and executed by var response = await mediator.ExecuteAsync(request);.

    /// <summary>
    /// DI signature: IRequestAsyncHandler&lt;TestAsyncRequest, TestResponse&gt;.
    /// <inheritdoc cref="IRequestAsyncHandler{TestAsyncRequest, TestResponse}"/>
    /// </summary>
    public class TestRequestAsyncHandler : IRequestAsyncHandler<TestAsyncRequest, TestResponse>
    {
        public async Task<TestResponse> ExecuteAsync(TestAsyncRequest request)
        {
            return await Task.Run(() => new TestResponse(request.Id));
        }
    }

C. DI Registration

Requires Scrutor for the automated registration.

See IntegrationTestDiFixture.cs for more details.

    private static void ConfigureServices(IServiceCollection services)
    {
        services.Scan(scan => scan
            .FromAssemblyDependencies(typeof(IntegrationTestDiFixture).Assembly)

                // Register IMediator
                .AddClasses(classes => classes.AssignableTo<IMediator>())
                .AsSelfWithInterfaces()
                .WithSingletonLifetime()

                // Register RequestHandlers, CommandHandlers - Async
                .AddClasses(classes => classes.AssignableTo(typeof(IRequestAsyncHandler<,>)))
                .AsImplementedInterfaces()
                .WithTransientLifetime()

                // Register RequestHandlers, CommandHandlers
                .AddClasses(classes => classes.AssignableTo(typeof(IRequestHandler<,>)))
                .AsImplementedInterfaces()
                .WithTransientLifetime()

                // Register CommandHandlers - Async
                .AddClasses(classes => classes.AssignableTo(typeof(ICommandAsyncHandler<>)))
                .AsImplementedInterfaces()
                .WithTransientLifetime()

                // Register CommandHandlers
                .AddClasses(classes => classes.AssignableTo(typeof(ICommandHandler<>)))
                .AsImplementedInterfaces()
                .WithTransientLifetime()

                // IDiDiscoverableTransient
                .AddClasses(classes => classes.AssignableTo(typeof(IDiDiscoverableTransient)))
                .AsImplementedInterfaces()
                .WithTransientLifetime()
        );
    }

D. Sample Class

• Simply inject IMediator in the constructor. See ConsumerClassWithMediator.cs for more details.

    public class ConsumerClassWithMediator : IConsumerClassWithMediator
    {
        private readonly IMediator mediator;

        public ConsumerClassWithMediator(IMediator mediator)        //<-Inject IMediator
        {
            this.mediator = mediator;
        }

        public async Task<TestResponse> DoSomething()
        {
            var request = new TestAsyncRequest(Guid.CreateVersion7());     //<-Request

            var response = await mediator.ExecuteAsync(request);    //<-Execute

            return response;                                        //<-Return Value
        }
    }

• This is the equivalent class without leveraging IMediator. See ConsumerClassWithoutMediator.cs for more details.

    public class ConsumerClassWithoutMediator : IConsumerClassWithoutMediator
    {
        private readonly IRequestAsyncHandler<TestAsyncRequest, TestResponse> handler;

        public ConsumerClassWithoutMediator(IRequestAsyncHandler<TestAsyncRequest, TestResponse> handler)     //<-Normal dependency injection. Inject handler
        {
            this.handler = handler;
        }

        public async Task<TestResponse> DoSomething()
        {
            var request = new TestAsyncRequest(Guid.CreateVersion7());     //<-Request

            var response = await handler.ExecuteAsync(request);      //<-Execute

            return response;                                        //<-Return Value
        }
    }

That's it.

Check out Eml.Mediator.vsix to automate the steps above.