Baixar AzureFromTheTrenches.Commanding - Baixar código-fonte AzureFromTheTrenches.Commanding

AzureFromTheTrenches.Commanding

Outras categorias

Custom HTTP Dispatch Error Handling

Baixar

AzureFromTheTrenches.Commanding

Observe que a documentação completa, incluindo guias e uma referência da API, pode ser encontrada no site de ajuda.

Também tenho uma série sobre como passar da arquitetura "camada cebola" para o uso de um padrão de comando mediado em uma série de postagens em meu blog.

Introdução

AzureFromTheTrenches.Commanding é uma estrutura de mediador de comando assíncrono baseada em configuração com vários objetivos principais de design:

Fornecer um mediador de alto desempenho para uso simples
Para apoiar a evolução ao longo do ciclo de vida de um projeto, permitindo fácil decomposição de uma arquitetura modular monolítica para uma arquitetura de microsserviços totalmente distribuída
Para fornecer uma abstração sem vazamentos sobre a semântica de envio e execução de comandos
Para reduzir o código padrão - de forma simplista, menos código significa menos erros e menos manutenção

Para apoiar esses objetivos, a estrutura oferece suporte ao .NET Standard 2.0 (e superior) e, portanto, pode ser usada em uma ampla variedade de cenários e vários pacotes de extensão totalmente opcionais estão disponíveis para permitir:

Construindo uma API REST diretamente a partir de comandos usando uma abordagem baseada em configuração
Despachando comandos para filas (Filas e Tópicos do Barramento de Serviço e Armazenamento do Azure)
Enviando comandos para hubs de eventos
Usando filas como fonte para execução de comandos
Armazenando comandos em cache com base em assinaturas em caches de memória local ou caches Redis

Você não precisa aproveitar essa funcionalidade, mas pode, se quiser, adotá-la ao longo do tempo sem alterar seu código principal.

Começando

Primeiro instale o pacote nuget para comandar:

 Install-Package AzureFromTheTrenches.Commanding

Como exemplo vamos criar um comando que soma dois números e retorna um resultado:

 public class MathResult
{
    public int Value { get; set; }
}

public class AddCommand : ICommand
{
    public int FirstNumber { get; set; }

    public int SecondNumber { get; set; }
}

Os comandos são acionados por manipuladores e nosso manipulador add se parece com isto:

 public AddCommandHandler : ICommandHandler
{
    public Task ExecuteAsync(AddCommand command, MathResult previousResult)
    {
        return new MathResult {
            Value = command.FirstNumber + command.SecondNumber
        };
    }
}

Tendo definido nosso comando, resultado e manipulador, precisamos registrá-los no sistema de comando. Se você está apenas escrevendo um aplicativo de console, você pode fazer isso em Program.cs, mas para um uso mais realista, você faria isso onde configura seu contêiner IoC - é útil pensar nos registros de comando como apenas mais uma parte da configuração de seus aplicativos, além do qual você precisará de acesso ao contêiner. O exemplo abaixo demonstra o registro no Microsoft ASP.Net Core Service Provider:

 // First register the commanding framework with the IoC container
IServiceProvider serviceProvider = null;
IServiceCollection serviceCollection = new ServiceCollection();
CommandingDependencyResolverAdapter adapter = new CommandingDependencyResolverAdapter(
    (fromType, toInstance) => services.AddSingleton(fromType, toInstance),
    (fromType, toType) => services.AddTransient(fromType, toType),
    (resolveTo) => _serviceProvider.GetService(resolveTo));
ICommandRegistry registry = adapter.AddCommanding();
serviceProvider = serviceCollection.BuildServiceProvider();

// Now register our handler
registry.Register();

A classe CommandingDependencyResolverAdapter é um adaptador que permite que o framework seja registrado em qualquer container IoC e o método AddCommanding registra as interfaces de comando injetáveis e retorna uma interface ICommandRegistry que permite registrar manipuladores - você só precisa registrar um manipulador, o framework vai figurar o resto e o registro usam um estilo de API fluente para um código legível e conciso.

Para despachar nosso comando, precisamos acessar a interface ICommandDispatcher e enviar o comando. Faremos isso e enviaremos o resultado para o console:

 ICommandDispatcher commandDispatcher = dependencyResolver.ServiceProvider.GetService();
MathResult mathResult = await commandDispatcher.DispatchAsync(new AddCommand { FirstNumber = 5, SecondNumber = 6});
Console.WriteLine(mathResult.Value); // hopefully says 11

E para uso simples é isso. Este exemplo é um pouco artificial, pois estamos resolvendo dependências manualmente e há muitos clichês para somar dois números, mas em cenários do mundo real tudo o que você realmente precisa fazer é registrar seus manipuladores de comando no local apropriado, por exemplo, se você Se você estiver usando o ASP.Net Core, todo o padrão de injeção de dependência estará em vigor.

Amostras

Execução simples de comando na memória https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/InMemoryCommanding
Despachando comandos por HTTP https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/HttpCommanding.Client
Executando comandos em resposta a solicitações HTTP (ASP.Net Core) https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/HttpCommanding.Web
Despachando e executando a partir de filas de armazenamento do Azure https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/AzureStorageQueueCommanding
Auditoria de armazenamento do Azure https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/AzureStorageAuditing
Auditoria do hub de eventos do Azure https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/AzureEventHubAuditing