IGet 1.1.3

IGet

Instantiate classes that are NOT in your service collection via i.Get<Class>(). Idea: use i.Get<Handler>().Handle(request) instead of mediatR.Send(request).

serviceCollection.AddIGet();

Why?

MediatR has positively shaped code bases of developers for many years. You might, however, like IGet better:

• you don't need to implement any interface for your handlers.
• creating a request class is optional.
• have compile-time checks that all handlers exist.
• use editor shortcuts to jump to a handler's method immediately.
• have a shorter StackTrace in case of an error.
• have more control to design complex processes.
• IGet is easier to understand than MediatR and it therefore might save money.
• IGet is extremely lightweight - less code often means fewer bugs.

IGet has only one responsibility - instantiating classes with their dependencies injected - but with this you can create MediatR-like structures easily. A basic IRequest-IRequestHandler structure needs less code if you use IGet and complex structures such as INotification-INotificationHandler are completely under your control.

Declaring a handler

Example 1

There is no need to implement IRequest and IRequestHandler<Request> or IRequest<Result> and IRequestHandler<Request, Result>. Choose another method name and use value type parameters if you want.

public class MyHandler
{
    private IConnectionFactory _connectionFactory;

    public MyHandler(IConnectionFactory connectionFactory)
    {
        _connectionFactory = connectionFactory;
    }

    public async Task<MyResult> ChooseASignature(int id)
    {
        // do something
    }
}

Example 2

Do you prefer synchronous code if possible? That's allowed!

public class MyHandler
{
    private ILogger<MyHandler> _logger;

    public MyHandler(ILogger<MyHandler> logger)
    {
        _logger = logger;
    }

    public void Handle()
    {
        // do something
    }
}

Sending a request

In the examples below i is the IGet instance where you call Get on. (Like mediator might have been the name of the variable for a IMediator instance where you called Send on.)

Example 1

var result = i.Get<MyHandler>().AnyRandomSignature(1);

Example 2

var handler = i.Get<MyHandler>();
handler.Handle();

Example 3

var result = await i.Get<MyHandler>().HandleAsync(new MyRequest
{
    Id = 2
});

Example 4

var result = i.Get<MyHandler>().Handle(request);

Because you get the handler via generics, your code is type-checked by the compiler - therefore you know that each request has a handler immediately. Also, you can place your cursor on the class's method and press F12 to quickly navigate to the method declaration.

More complex scenarios

Example 1

Handlers may get other handlers to do stuff for them, like validation, pre-processing and post-processing.

var result = await i.Get<MoreComplexHandler>().Handle(request);

public class MoreComplexHandler
{
    private ILogger<MoreComplexHandler> _logger;
    private IGet i;

    public MoreComplexHandler(IGet iget, ILogger<MoreComplexHandler> logger)
    {
        _logger = logger;
        i = iget;
    }

    public Result<WhatWasAskedFor> Handle(Request request)
    {
        try
        {
            var validationResult = i.Get<Validator>().Validate(request);
            if (!validationResult.IsValid)
            {
                return Result.Fail<WhatWasAskedFor>(validationResult.Message);
            }

            i.Get<PreProcessor>().Prepare(request);
            var whatWasAskedFor = i.Get<MainProcessor>().Handle(request);

            try
            {
                i.Get<PostProcessor>().DoLessImportantStuffWith(request, whatWasAskedFor);
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "PostProcessor failed for request {requestId}.", request.Id);
            }

            return Result.Success(whatWasAskedFor);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Unexpected error for request {requestId}.", request.Id);
            return Result.Fail<WhatWasAskedFor>("Something went wrong. Try again later.");
        }
    }
}

Example 2

The functionality of MediatR's INotification-INotificationHandler combination can be created via something like this:

await i.Get<NotificationPublisher>().PublishAsync(notification);

public class NotificationPublisher
{
    private IGet i;

    public NotificationPublisher(IGet iget)
    {
        i = iget;
    }

    public async Task PublishAsync(Notification notification)
    {
        try
        {
            await i.Get<FirstHandler>().HandleAsync(notification);
        }
        catch { }
        try
        {
            await i.Get<SecondHandler>().HandleAsync(notification);
        }
        catch { }
        try
        {
            i.Get<ThirdHandler>().Handle(notification);
        }
        catch { }
    }
}

Notes:

• Exceptions should be logged in the catch blocks.
• If you find the example above too risky - because you might forget to register a newly created handler in the publisher, then have a look at IGet.GetAll. You can ask IGet.GetAll to return an instance of each class that implements a certain interface, for example IMyNotification<MyRequest>. It uses i.Get<T>(type) from this library for instantiating the type and casting it to T and it has a "memory" to increase performance on next calls.

Example 3

You may want multiple handlers to have certian behaviour, for example logging their execution time. You could create a base class for (a subset of) your handlers:

public abstract class BaseHandler<THandler,TRequest, TResponse>
    where THandler : notnull
    where TRequest : notnull
{
    protected readonly ILogger<THandler> _logger;
    protected readonly IDbConnectionFactory _connectionFactory;
    protected readonly IHostEnvironment _hostEnvironment;

    public BaseHandler(IBaseHandlerServices baseHandlerServices)
    {
        _logger = baseHandlerServices.LoggerFactory.CreateLogger<THandler>();
        _connectionFactory = baseHandlerServices.ConnectionFactory;
        _hostEnvironment = baseHandlerServices.HostEnvironment;
    }
    public async Task<TResponse> HandleAsync(TRequest request, CancellationToken cancellationToken = default)
    {
        HandleBefore(request);
        var result = await HandleCoreAsync(request, cancellationToken);
        HandleAfter();
        return result;
    }

    private void HandleBefore(TRequest request)
    {
        if (!_hostEnvironment.IsProduction())
        {
            _logger.LogInformation("Start handling request {RequestMembers}.", request.ToKeyValuePairsString());
        }
        StartTime = DateTime.UtcNow;
    }
    DateTime StartTime;
    protected abstract Task<TResponse> HandleCoreAsync(
        TRequest request, 
        CancellationToken cancellationToken);
    private void HandleAfter()
    {
        var totalMilliseconds = (DateTime.UtcNow - StartTime).TotalMilliseconds;
        if (!_hostEnvironment.IsProduction() || totalMilliseconds > 500)
        {
            _logger.LogInformation("Finished in {TotalMilliseconds}ms.", totalMilliseconds);
        }
    }
}

Inherit:

public class ProductOverviewQueryHandler 
    : BaseHandler<ProductOverviewQueryHandler, Query, Result>
{
    public ProductOverviewQueryHandler(IBaseHandlerServices baseHandlerServices) 
        : base(baseHandlerServices)
    { }

    protected override async Task<Result> HandleCoreAsync(
        Query query,
        CancellationToken cancellationToken)
    {
        await using var connection = await _connectionFactory.GetOpenConnectionAsync(cancellationToken);

        // execute

        return new Result
        {
            // set properties
        };
    }
}

Use:

var result = await i.Get<ProductOverviewQueryHandler>().HandleAsync(query);

Try it out

The examples above give an idea of how you can be creative with IGet. Share your own examples online to spread the word about IGet.