web-dev-qa-db-fra.com

Comment rendre une méthode partielle async

J'ai un code généré avec une méthode partielle 

{
    ...
    partial void InterceptOperationCall(IOperationContext context);
    ...

    async Task SomeMethod()
    {
        InterceptOperationCall(cntx);
        await LongOperation(cntx);
    }
}

et partielle manuscrite

{
    partial void InterceptOperationCall(IOperationContext context)
    {
    }
}

Je dois faire des appels asynchrones dans InterceptOperationCall Est-ce que quelqu'un connaît un moyen de contourner les restrictions de méthodes partielles?

Un autre mot: Je veux utiliser InterceptOperationCall de manière asynchrone et garanti avant une opération prolongée, mais je souhaite également déclarer le corps de cette méthode dans un autre fichier.

UPD comme solution de contournement, j'ai choisi de:

  • ne pas utiliser les méthodes partielles générées, encapsuler avec un proxy dynamique (Castle.DynamicProxy) et intercepter avec AsyncInterceptorBase à partir de (Nito.AsyncEx)
  • une autre option que je vois réécrire codegenerator

De toute façon, je continue de chercher une meilleure solution, et si quelqu'un connaît un autre moyen de fournir une possibilité facultative de terminer des appels asynchrones avec une certaine logique async, veuillez m'aider.

c#asynchronousauto-generate
9
gabba

Les méthodes partielles sont comme des interfaces. Ils sont un contrat . Quiconque implémentant la méthode partielle, comme une méthode d'interface, remplit ce contrat. Dans ce cas, le contrat de la méthode est une méthode synchrone. Il n'y a aucun moyen d'avoir une implémentation asynchrone, car une implémentation asynchrone appropriée de cette méthode nécessite que l'appelant de la méthode sache qu'il s'agit d'une méthode asynchrone et agisse en conséquence. Comme l'appelant a écrit le contrat comme étant une méthode synchrone, cela ne se produit pas.

Vos solutions consistent donc à modifier le contrat pour que la méthode soit asynchrone, c'est-à-dire à changer la déclaration de la méthode partielle, ou à fournir une implémentation synchrone plutôt qu'asynchrone.

Je suppose qu'une troisième option serait de faire en sorte que l'interface (dans ce cas, les méthodes partielles) prenne en charge les deux. Avoir deux méthodes partielles, une asynchrone, une synchrone, et laisser l'implémentation fournir celle qu'elles veulent.

1
Servy

Je ne vois pas de solution à ce problème qui ne souffre pas de tous les inconvénients du vide asynchrone en général (comme cela a été discuté dans l'article lié de Stephen Cleary dans le commentaire de Peter Schneider).

Je pense que votre meilleur choix si vous ne pouvez pas trouver ou écrire une version de synchronisation des API asynchrones en question est d'appeler les méthodes asynchrones, puis utilisez task.Wait () pour attendre son achèvement. Si vous avez plusieurs appels asynchrones, composez-les avec ContinueWith. En gros, vous devez utiliser la bibliothèque de tâches dans le style .Net 4.0.

0
Jonas Høgh