Meilleures pratiques pour les appels asynchrones dans MVP avec WinForms

Question

J'utilise le modèle Model-View-Presenter dans un projet WinForms et un de mes problèmes (parmi beaucoup d'autres) est lorsque le formulaire indique au présentateur de faire quelque chose, puis non-réactif pendant que le présentateur va de le faire. Heureusement, dans mon projet, je n'ai aucun problème à faire asynchrone tous les appels de présentateur la question est de savoir exactement comment le faire?

Si chaque appel du présentateur vient envelopper dans une nouvelle création de fil? *

new Thread(()=>_presenter.DoSomething()).Start(); 

Quelles sont les meilleures pratiques ici? Que faire si l'utilisateur appuie sur le bouton "Abandonner ce que vous faites"? Comment puis-je avorter avec élégance?

. * De façon réaliste, j'utiliser probablement une sorte de proxy sur le présentateur de le faire plutôt que de mettre la création de fil dans le WinForm

Answer 1

Je peux seulement prétendre que j'ai réfléchi à cela (avant de lire votre question;). D'abord, je truquerais les endroits où cela compte vraiment; par exemple le chokepoint d'accès à la base de données. S'il y a une place qui ne devrait pas être exécutée dans le contexte "UI" (vous pouvez l'enregistrer de http://msdn.microsoft.com/en-us/library/system.threading.synchronizationcontext.current.aspx dans le thread UI, puis comparer plus tard au contexte de synchronisation non-UI) puis Debug.BitchAndMoan() à ce sujet. Tout calcul plus long (qui «devrait» être clairement séparé dans ses propres variétés, à droite) devrait l'affirmer.

Je suppose que vous devriez au moins rendre le type d'exécution de la fonction de présentateur configurable via l'attribut qui est ensuite obéi par proxy. (juste au cas où vous voulez quelque chose fait en série).

L'annulation d'une tâche est en fait le problème du présentateur, mais vous devez avoir un objet de référence qui indique ce que vous voulez arrêter. Si vous optez pour le proxy, vous pouvez récupérer les threads créés dans la liste des tâches avec IAsyncResult, mais c'est toujours un problème de décider lequel est supposé être annulé si la même action peut être appelée plusieurs fois en parallèle. Vous devez donc fournir à la tâche un nom spécifique à l'appel approprié lorsque vous le lancez; ce qui implique beaucoup trop de logique dans le côté View -> Presenter devrait probablement demander à View de demander à l'utilisateur quelle tâche doit être éliminée. Mon expérience est que cela est généralement fait juste en utilisant des événements (style SCSF). Si je le faisais à partir de zéro, j'irais par procuration puisque SCSF a été une source de souffrance de tellement de façons que je doute de la santé mentale de ses concepteurs.

Answer 2

Pourquoi ne pas faire le modèle de proxy que vous utilisez accepter quelques rappels retourner les résultats ou annuler?

Answer 3

je place généralement toute action qui peut (réaliste) prendre plus d'une seconde ou deux dans une tâche distincte, quelque chose comme:

public interface ITask 
{ 
    void ExecuteTask (ITaskExecutionContext context); 
    void AfterSuccess(ITaskExecutionContext context); 
    void AfterFailure(ITaskExecutionContext context); 
    void AfterAbortion(ITaskExecutionContext context); 
} 

J'ai aussi une abstraction pour l'exécution de ces tâches:

public interface ITaskExecutor : IDisposable 
{ 
    void BeginTask(ITask task); 
    void TellTaskToStop(); 
} 

l'une des implémentations de cette ITaskExecutor utilise la bonne BackgroundWorker:

public class BackgroundTaskExecutor : ITaskExecutor 
{ 
    public void BeginTask(ITask task) 
    { 
     this.task = task; 
     worker = new BackgroundWorker(); 
     worker.DoWork += WorkerDoWork; 
     worker.RunWorkerCompleted += WorkerRunWorkerCompleted; 
     worker.WorkerSupportsCancellation = true; 

     worker.RunWorkerAsync(); 
    } 

    ... 
} 

Je compte beaucoup sur l'injection de dépendance et IoC pour câbler les choses ensemble. Dans le présentateur alors je viens d'appeler quelque chose comme:

GoAndDontReturnUntilYouBringMeALotOfMoneyTask task = new GoAndDontReturnUntilYouBringMeALotOfMoneyTask(parameters); 
taskExecutor.BeginTask(task); 

Annuler/avortent boutons sont ensuite câblés afin qu'ils disent l'exécuteur des tâches/tâche d'avorter.C'est en fait un peu plus complexe que présenté ici, mais c'est l'idée générale.