ResultCommander.Autofac 2.2.2

ResultCommander

Library featuring a command handler pattern for both synchronous and asynchronous operations.

Uses a functional Result approach for failure-prone operations.

To utilize all features using Autofac is required.

Features

• Synchronous and asynchronous command handler definitions
• Definitions and base implementations of commands
• Supports decorators and adapters via Autofac's methods

Description

There are two command types - one that only returns a Result and one that returns an additional entity contained within the Result.

Every handler must return a Result struct which determines whether the operation succedeed or not, handlers may or may not return additional results contained within the Result struct - this is defined by the handled comand.

Installation

To register handlers with the DI container use the ContainerBuilder or IServiceCollection extension methods provided by the library:

builder.AddResultCommander(assembliesToScan);

To register decorators or adapters use the methods available on ResultCommanderConfiguration like so:

builder.AddResultCommander(assembliesToScan, options => 
{
    options.AddDecorator<FancyDecorator, ISyncCommandHandler<SimpleCommand>();
});

You can register multiple decorators and they'll be applied in the order that you register them - read more at Autofac's docs regarding decorators and adapters.

Documentation

Documentation available at https://mikym.github.io/ResultCommander/.

Download

• ResultCommander - NuGet
• ResultCommander.Autofac - NuGet

Example usage

<b> You should never throw exceptions from within handlers, they should be exception free - instead return appropriate error results (and catch possible exceptions).</b> Library offers a simple error catching, logging and exception to result error decorators for uses where writing try-catch blocks becomes a pain - but remember that these results will never be as informative as manually returned proper result error types.

A command without a concrete result:

public record SimpleCommand(bool IsSuccess) : ICommand;

And a synchronous handler that handles it:

public class SimpleSyncCommandHandler : ISyncCommandHandler<SimpleCommand>
{
    public Result Handle(SimpleCommand command)
    {
        if (command.IsSuccess)
            return Result.FromSuccess();
            
        return new InvalidOperationError();
    }
}

A command with a concrete result:

public record SimpleCommandWithConcreteResult(bool IsSuccess) : ICommand<int>;

And an asynchronous handler that handles it:

public SimpleAsyncCommandHandlerWithConcreteResult : IAsyncCommandHandler<SimpleCommand, int>
{
    public async Task<Result<int>> Handle(SimpleCommand command)
    {
        if (command.IsSuccess)
            return 1;
            
        return new InvalidOperationError();
    }
}