Descarga de AzureFromTheTrenches.Commanding - Descarga de código fuente de AzureFromTheTrenches.Commanding

AzureFromTheTrenches.Commanding

Otras categorias

Custom HTTP Dispatch Error Handling

Descargar

AzureFromTheTrenches.Commanding

Tenga en cuenta que la documentación completa, incluidas guías y una referencia de API, se puede encontrar en el sitio de ayuda.

También tengo una serie de publicaciones en mi blog sobre cómo pasar de la arquitectura de "capa de cebolla" al uso de un patrón de comando mediado.

Introducción

AzureFromTheTrenches.Commanding es un marco de mediador de comandos asincrónico basado en configuración con varios objetivos de diseño clave:

Proporcionar un mediador de alto rendimiento para un uso sencillo.
Apoyar la evolución a lo largo del ciclo de vida de un proyecto, permitiendo una fácil descomposición de un monolito modular a una arquitectura de microservicio completamente distribuida.
Proporcionar una abstracción sin fugas sobre la semántica de envío y ejecución de comandos.
Para reducir el código repetitivo: de manera simplista, menos código significa menos errores y menos mantenimiento

Para respaldar estos objetivos, el marco admite .NET Standard 2.0 (y superior) y, por lo tanto, se puede utilizar en una amplia variedad de escenarios y hay disponibles varios paquetes de extensión totalmente opcionales para habilitar:

Creación de una API REST directamente a partir de comandos utilizando un enfoque basado en configuración
Envío de comandos a colas (temas y colas de Service Bus y almacenamiento de Azure)
Envío de comandos a centros de eventos
Usar colas como fuente para ejecutar comandos
Comandos de almacenamiento en caché basados en firmas en cachés de memoria local o cachés de Redis

No necesita aprovechar esa funcionalidad pero, si lo desea, puede adoptarla con el tiempo sin cambiar su código principal.

Empezando

Primero instale el paquete nuget para ordenar:

 Install-Package AzureFromTheTrenches.Commanding

Como ejemplo, creemos un comando que suma dos números y devuelve un resultado:

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

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

    public int SecondNumber { get; set; }
}

Los controladores actúan sobre los comandos y nuestro controlador de adición tiene este aspecto:

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

Una vez definido nuestro comando, resultado y controlador, debemos registrarlos en el sistema de comando. Si solo está escribiendo una aplicación de consola, puede hacerlo en Program.cs, pero para un uso más realista, puede hacerlo cuando configura su contenedor IoC; es útil pensar en los registros de comandos como una parte más de la configuración de sus aplicaciones. además de lo cual necesitarás acceso al contenedor. El siguiente ejemplo demuestra el registro con el proveedor de servicios principales de Microsoft ASP.Net:

 // 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();

La clase CommandingDependencyResolverAdapter es un adaptador que permite que el marco se registre con cualquier contenedor IoC y el método AddCommanding registra las interfaces de comando inyectables y devuelve una interfaz ICommandRegistry que le permite registrar controladores; solo necesita registrar un controlador, el marco lo resolverá. El resto y el registro utilizan un estilo API fluido para un código conciso y legible.

Para enviar nuestro comando, necesitamos acceder a la interfaz ICommandDispatcher y enviar el comando. Haremos eso y enviaremos el resultado a la consola:

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

Y para un uso sencillo, eso es todo. Este ejemplo es un poco artificial ya que estamos resolviendo dependencias a mano y hay muchos textos repetitivos para sumar dos números, pero en escenarios del mundo real todo lo que realmente necesitas hacer es registrar tus controladores de comandos en el lugar apropiado, por ejemplo si Si estás usando ASP.Net Core, entonces todo el texto estándar de inyección de dependencia estará implementado.

Muestras

Ejecución simple de comandos en memoria https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/InMemoryCommanding
Envío de comandos a través de HTTP https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/HttpCommanding.Client
Ejecutar comandos en respuesta a solicitudes HTTP (ASP.Net Core) https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/HttpCommanding.Web
Envío y ejecución desde colas de Azure Storage https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/AzureStorageQueueCommanding
Auditoría de almacenamiento de Azure https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/AzureStorageAuditing
Auditoría del centro de eventos de Azure https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/AzureEventHubAuditing