EDITH says (tl;dr)

je suis allé avec une variante de la solution suggérée; garder tout ICommandHandleret IQueryHandler s potentiellement aynchrone et renvoie une tâche résolue dans les cas synchrones. Encore, je ne veux pas utiliser Task.FromResult(...) tous les coins de la place, j'ai donc défini une méthode d'extension pour plus de commodité:

public static class TaskExtensions
{
    public static Task<TResult> AsTaskResult<TResult>(this TResult result)
    {
        // Or TaskEx.FromResult if you're targeting .NET4.0 
        // with the Microsoft.BCL.Async package
        return Task.FromResult(result); 
    }
}

// Usage in code ...
using TaskExtensions;
class MySynchronousQueryHandler : IQueryHandler<MyQuery, bool>
{
    public Task<bool> Handle(MyQuery query)
    {
        return true.AsTaskResult();
    }
}

class MyAsynchronousQueryHandler : IQueryHandler<MyQuery, bool>
{
    public async Task<bool> Handle(MyQuery query)
    {
        return await this.callAWebserviceToReturnTheResult();
    }
}

il est dommage que C# ne soit pas Haskell ... encore 8 -). Ça sent vraiment comme une application de Flèches. De toute façon, espérons que cette aide quiconque. Maintenant à ma question originale: -)

Introduction

Bonjour à tous!

pour un projet, je suis en train de concevoir une architecture d'application en C# (.NET4.5, C # 5.0, ASP.NET MVC4). Avec cette question, j'espère avoir quelques opinions sur certaines questions que je suis tombé sur essayer d'intégrer async/await. Remarque: c'est assez long :-)

ma structure de solution ressemble à ceci:

• MyCompany.Contract (Commandes/Requêtes et interfaces communes)
• MyCompany.MyProject (Contient la logique métier et de commande/de requête gestionnaires)
• MyCompany.MyProject.Web (MVC web frontend)

j'ai lu sur l'architecture maintenable et commande-requête-séparation et j'ai trouvé ces messages très utiles:

• pendant ce temps, sur la requête du côté de mon architecture
• pendant ce temps, sur la commande de côté de mon architecture
• écriture services hautement maintenables de la FMC

jusqu'à présent, j'ai la tête autour de l' ICommandHandler/IQueryHandler concepts et l'injection de dépendance (je suis en utilisant SimpleInjector - c'est vraiment simple).

L'Approche Donnée

L'approche des articles ci-dessus suggère d'utiliser POCOs que les commandes/requêtes et décrit les répartiteurs de ces implémentations de la fonction suivante interfaces:

interface IQueryHandler<TQuery, TResult>
{
    TResult Handle(TQuery query);
}

interface ICommandHandler<TCommand>
{
    void Handle(TCommand command);
}

dans un MVC Contrôleur que vous souhaitez utiliser comme suit:

class AuthenticateCommand
{
    // The token to use for authentication
    public string Token { get; set; }
    public string SomeResultingSessionId { get; set; }
}

class AuthenticateController : Controller
{
    private readonly ICommandHandler<AuthenticateCommand> authenticateUser;

    public AuthenticateController(ICommandHandler<AuthenticateCommand> authenticateUser) 
    {
        // Injected via DI container
        this.authenticateUser = authenticateUser;
    }

    public ActionResult Index(string externalToken)
    {
        var command = new AuthenticateCommand 
        { 
            Token = externalToken 
        };
        this.authenticateUser.Handle(command);

        var sessionId = command.SomeResultingSessionId;
        // Do some fancy thing with our new found knowledge
    }
}

Certains de mes observations à ce sujet:

1. pure CQS seules les requêtes devraient retourner des valeurs alors que les commandes devraient être, et bien seulement des commandes. En réalité, il est plus pratique pour les commandes de retourner des valeurs au lieu d'émettre la commande et de faire ensuite une requête pour la chose que la commande aurait dû retourner en premier lieu (par exemple ids de base de données ou similaire). C'est pourquoi la l'auteur a suggéré mettre une valeur de retour dans la commande POCO.
2. il n'est pas très évident ce qui est retourné d'une commande, en fait il regarde comme la commande est un feu et oublier type de chose jusqu'à ce que vous rencontriez éventuellement la propriété de résultat bizarre étant accédé après le handler a couru plus la commande sait maintenant à propos de son résultat
3. Les gestionnaires d' pour être synchrone pour que cela fonctionne - requêtes ainsi que les commandes. Comme il s'avère qu'avec C#5.0 vous pouvez injecter async/await powered handlers avec l'aide de votre conteneur DI préféré, mais le compilateur ne le sait pas au moment de la compilation, donc le handler MVC va échouer misérablement avec une exception vous disant que la méthode est revenue avant que toutes les tâches asynchrones aient fini d'exécuter.

bien sûr, vous pouvez marquer le handler MVC comme async et c'est sur quoi porte cette question.

Commandes Retournant Des Valeurs

je réflexion sur l'approche donnée et modifications apportées aux interfaces pour régler les problèmes 1. et 2. j'ai ajouté un ICommandHandler qui a un type de résultat explicite - tout comme le IQueryHandler. Cela viole toujours CQS mais au moins il est évident que ces commandes retournent une sorte de valeur avec l'avantage supplémentaire de ne pas avoir à encombrer l'objet de commande avec une propriété de résultat:

interface ICommandHandler<TCommand, TResult>
{
    TResult Handle(TCommand command);
}

naturellement, on pourrait faire valoir que lorsque vous avez la même interface pour les commandes et QUESTIONS Pourquoi s'embêter? Mais je pense que ça vaut la peine de les nommer autrement - ça a juste l'air plus propre à mes yeux.

Ma Solution Préliminaire

puis j'ai beaucoup réfléchi au 3e numéro à portée de main ... certains de mes gestionnaires de commandes/requêtes doivent être asynchrones (par exemple, émettre un WebRequest vers un autre service web pour authentification) d'autres non. J'ai donc pensé qu'il serait préférable de concevoir mes handlers à partir de la base pour async/await - qui, bien sûr, fait des bulles jusqu'aux manipulateurs MVC même pour les gestionnaires qui sont en fait de façon synchrone:

interface IQueryHandler<TQuery, TResult>
{
    Task<TResult> Handle(TQuery query);
}

interface ICommandHandler<TCommand>
{
    Task Handle(TCommand command);
}

interface ICommandHandler<TCommand, TResult>
{
    Task<TResult> Handle(TCommand command);
}

class AuthenticateCommand
{
    // The token to use for authentication
    public string Token { get; set; }

    // No more return properties ...
}

AuthenticateController:

class AuthenticateController : Controller
{
    private readonly ICommandHandler<AuthenticateCommand, string> authenticateUser;

    public AuthenticateController(ICommandHandler<AuthenticateCommand, 
        string> authenticateUser) 
    {
        // Injected via DI container
        this.authenticateUser = authenticateUser;
    }

    public async Task<ActionResult> Index(string externalToken)
    {
        var command = new AuthenticateCommand 
        { 
            Token = externalToken 
        };
        // It's pretty obvious that the command handler returns something
        var sessionId = await this.authenticateUser.Handle(command);

        // Do some fancy thing with our new found knowledge
    }
}

bien que cela résolve mes problèmes-valeurs de retour évidentes, tous les gestionnaires peuvent être async - cela me fait mal au cerveau de mettre async sur un truc qui n'est pas asynchrone juste parce que. Il y a plusieurs inconvénients que je vois avec ceci:

• les interfaces de handler ne sont pas aussi soignées que je le voulais - les Task<...> les choses à mes yeux sont très verbeuses et à première vue dissimuler le fait que je ne veux retourner quelque chose à partir d'une requête/commande
• Le compilateur vous avertit de ne pas avoir un approprié await dans les implémentations de handler synchrones (je veux pouvoir compiler mes ReleaseWarnings as Errors) - vous pouvez l'écraser avec un pragma ... ouais. .. bien. ..
• j'ai pu omettre l' async mot-clé dans ces cas pour rendre le compilateur heureux mais pour mettre en œuvre l'interface de handler vous devriez retourner certains sorte de Task explicitement - c'est assez laid
• je pourrais fournir des versions synchrones et asynchrones des interfaces handler (ou les mettre toutes dans une interface gonflant l'implémentation) mais je crois comprendre que, idéalement, le consommateur d'un handler ne devrait pas être conscient du fait qu'un handler commande/requête est synchrone ou asynchrone car c'est une préoccupation transversale. Que faire si j'ai besoin de faire un autrefois commande synchrone asynchrone? Je dois changer tous les consommateurs de la handler risque de briser la sémantique en parcourant le code.
• d'autre part, l' éventuellement-async-gestionnaires-approche serait à même de me donner la possibilité de changer de synchroniser les maîtres de async en les décorant avec l'aide de mon DI conteneur

pour l'instant je ne vois pas solution à cette question ... Je suis à une perte.

Quelqu'un ayant un problème similaire et une solution élégante à laquelle je n'ai pas pensé?