Notez qu'une documentation complète comprenant des guides et une référence API est disponible sur le site d'aide.
J'ai également une série sur le passage de l'architecture « couche d'oignon » à l'utilisation d'un modèle de commande médiatisée dans une série d'articles sur mon blog.
AzureFromTheTrenches.Commanding est un framework de médiateur de commandes asynchrone basé sur la configuration avec un certain nombre d'objectifs de conception clés :
Pour atteindre ces objectifs, le framework prend en charge .NET Standard 2.0 (et versions ultérieures) et peut donc être utilisé dans une grande variété de scénarios. Un certain nombre de packages d'extension entièrement facultatifs sont disponibles pour activer :
Vous n'avez pas besoin de profiter de cette fonctionnalité mais vous pouvez, si vous le souhaitez, l'adopter au fil du temps sans modifier votre code principal.
Installez d’abord le package nuget pour commander :
Install-Package AzureFromTheTrenches.Commanding
À titre d'exemple, créons une commande qui additionne deux nombres et renvoie un résultat :
public class MathResult
{
public int Value { get; set; }
}
public class AddCommand : ICommand
{
public int FirstNumber { get; set; }
public int SecondNumber { get; set; }
}
Les commandes sont exécutées par des gestionnaires et notre gestionnaire d'ajout ressemble à ceci :
public AddCommandHandler : ICommandHandler
{
public Task ExecuteAsync(AddCommand command, MathResult previousResult)
{
return new MathResult {
Value = command.FirstNumber + command.SecondNumber
};
}
}
Après avoir défini notre commande, notre résultat et notre gestionnaire, nous devons les enregistrer auprès du système de commande. Si vous écrivez simplement une application console, vous pouvez le faire dans Program.cs, mais pour une utilisation plus réaliste, vous le feriez lorsque vous configurez votre conteneur IoC - il est pratique de considérer les enregistrements de commandes comme une autre partie de la configuration de vos applications. en plus de cela, vous aurez besoin d’accéder au conteneur. L'exemple ci-dessous illustre l'inscription auprès du fournisseur de services Microsoft ASP.Net Core :
// 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 classe CommandingDependencyResolverAdapter est un adaptateur qui permet au framework d'être enregistré auprès de n'importe quel conteneur IoC et la méthode AddCommanding enregistre les interfaces de commande injectables et renvoie une interface ICommandRegistry qui vous permet d'enregistrer des gestionnaires - il vous suffit d'enregistrer un gestionnaire, le framework figurera le reste et l'enregistrement utilisent un style API fluide pour un code concis et lisible.
Pour envoyer notre commande, nous devons mettre la main sur l'interface ICommandDispatcher et envoyer la commande. Nous allons faire cela et afficher le résultat sur la console :
ICommandDispatcher commandDispatcher = dependencyResolver.ServiceProvider.GetService();
MathResult mathResult = await commandDispatcher.DispatchAsync(new AddCommand { FirstNumber = 5, SecondNumber = 6});
Console.WriteLine(mathResult.Value); // hopefully says 11
Et pour une utilisation simple, c'est tout. Cet exemple est un peu artificiel car nous résolvons les dépendances à la main et il y a beaucoup de passe-partout pour additionner deux nombres, mais dans les scénarios du monde réel, tout ce que vous avez à faire est d'enregistrer vos gestionnaires de commandes à l'endroit approprié, par exemple si vous Si vous utilisez ASP.Net Core, alors tout le passe-partout d'injection de dépendances est en place.
Exécution simple de commandes en mémoire https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/InMemoryCommanding
Envoi de commandes via HTTP https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/HttpCommanding.Client
Exécution de commandes en réponse aux requêtes HTTP (ASP.Net Core) https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/HttpCommanding.Web
Distribution et exécution à partir des files d'attente de stockage Azure https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/AzureStorageQueueCommanding
Audit du stockage Azure https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/AzureStorageAuditing
Audit Azure Event Hub https://github.com/JamesRandall/AzureFromTheTrenches.Commanding/tree/master/Samples/AzureEventHubAuditing
D'autres scénarios d'utilisation peuvent être trouvés dans le wiki, notamment :
Si vous êtes bloqué, enregistrez un problème GitHub ou retrouvez-moi sur Twitter à @azuretrenches et je vous aiderai si je peux.