IGet 1.0.6

IGet

Say goodbye to MediatR's IRequest-IRequestHandler combination and use IGet instead: less code, more freedom.

serviceCollection.AddIGet();

Why?

You're probably very happy with how MediatR solves injecting dependencies into your IRequestHandler implementations. You might however like IGet better as a simpler alternative for the IRequest-IRequestHandler combination:

• 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.
• etc.

IGet can also be used to structure code that previously used the INotification-INotificationHandler combination or things like the IRequestPostProcessor, but IGet itself is nothing special: it just instantiates a classes with their dependencies injected. See the examples below.

Declaring a handler

Example 1

public class MyHandler
{
    private ILogger<MyHandler> _logger;

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

    public MyResult AnyRandomSignature(int id)
    {
        // do something
    }
}

Example 2

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
});

etc.

More complex scenarios

Example 1

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

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

When you think of notifications, you might think of subscribers. MediatR does not support this concept of subscribing at runtime. A notification publisher that allows subscribing handlers at runtime is also out of the problem scope for this package - not because it is too hard to create, but because that problem deserves a package of its own.

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

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 { }
    }
}

which can be called via

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

Example 3

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.

Try it out

What problem would you like to solve today? Give it a try!