IGet 1.1.1

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) - for less code (in total) and more freedom.

serviceCollection.AddIGet();

Why?

Having MediatR working is nice. 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 method immediately.
• have a shorter StackTrace in case of an error.
• have more control for designing complex processes.
• etc.

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.
• Let's say that you have several handlers that implement INotificationHandler<ChallengeAccepted> and via reflection you get all those handlers as a Type[] (in a static property of type Lazy<Type[]>). Then use i.Get<T>(type) for instantiating the type and casting it to T:

foreach (Type handlerType in LazyChallengeAcceptedNotificationHandlers)
{
    try
    {
        var handler = await i.Get<INotificationHandler<ChallengeAccepted>>(handlerType);
        await handler.Handle(challengeAcceptedNotification);
    }
    catch { }
}

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.

If you're interested in the source code of this library, then use IGet in Visual Studio and press F12 with your cursor on the AddIGet() extension method.