Voulez-vous que le gestionnaire d'événements s'exécute une seule fois/Conception de la machine d'état?

Question

J'ai un service Web avec deux méthodes:

RetrieveFirstLevelOptions() et RetrieveSecondLevelOptions (int levelOneOption).

L'interface graphique contient deux zones de liste déroulante: FirstLevelOptionsCombo et SecondLevelOptionsCombo.

J'ai un problème avec la création d'un flux de contrôle pour l'étape d'initialisation lorsque je dois faire une demande à RetrieveFirstLevelOptions() et, une fois les résultats obtenus, appeler RetrieveSecondLevelOptions (par défaut levelOneOption = 0). Le problème est que puisque tout se passe de manière asynchrone, je ne sais pas quelle est la meilleure approche pour permettre que ce comportement se produise une fois et une seule fois, au début.

Une option que j'aimerais tant est d'attacher un deuxième gestionnaire d'événements à l'événement RetieveFirstLevelOptionsCompleted et de le supprimer lui-même après une seule exécution. Mais il semble qu'un tel comportement soit impossible à obtenir.

Une autre option consisterait à avoir un indicateur booléen pour indiquer si dans la phase d'initialisation et si c'est le cas, le gestionnaire de RetrieveFirstLevelOptionsCompleted exécuterait une logique supplémentaire. Cependant, cette idée donne l'impression que tous les gestionnaires d'événements doivent vérifier les informations d'état et faire des choses différentes en fonction de l'état actuel. Cela semble être une mauvaise conception parce que le flux de contrôle semble décentralisé.

Je veux avoir un mécanisme de flux de contrôle centralisé qui prendra les décisions en un seul endroit. Mais comment cela peut-il être fait quand tout est exécuté de manière asynchrone?

Answer 1

"Une option que j'aimerais tant est d'attacher un second gestionnaire d'événements à l'événement RetieveFirstLevelOptionsCompleted et de le supprimer lui-même après une seule exécution, mais il semble qu'un tel comportement soit impossible à obtenir."

Y at-il une raison quelconque cela ne fonctionne pas:

class Example 
{ 
    SomeWebService myService; 

    Example() 
    { 
     // do stuff 
     myService.RetrieveFirstLevelOptionsCompleted += MyHandlerMethod; 
    } 

    void MyHandlerMethod(object sender, RetrieveFirstLevelOptionsCompletedEventArgs e) 
    { 
     // do stuff 
     myService.RetrieveFirstLevelOptionsCompleted -= MyHandlerMethod; 
     // potentially attach next event handler for all subsequent calls 
     myService.RetrieveFirstLevelOptionsCompleted += MyHandlerMethod2; 
    } 
} 

Answer 2

Le modèle que j'utilise habituellement dans une situation comme celle-ci consiste à créer un wrapper autour de la méthode de proxy de service Web Async qui accepte une méthode de rappel. La méthode de rappel obtient ensuite transmis à la méthode RetrieveFirstLevelOptionsAsync() comme ceci:

public void RetrieveFirstLevelOptions(Action callback) 
{ 
    client.RetrieveFirstLevelOptionsAsync(callback); 
} 

void client_RetrieveFirstLevelOptionsCompleted(object sender, AsyncCompletedEventArgs e) 
{ 
    var callback = e.UserState as Action; 
    if (callback != null) 
    { 
     callback(); 
    } 
} 

Ainsi, lorsque vous appelez RetrieveFirstLevelOptions(), vous passez juste le rappel que vous voulez exécuter une seule fois, et vous ne disposent pas toujours de s'inquiéter de se faire appeler plusieurs fois. Vraisemblablement, vous mettriez votre appel à RetrieveSecondLevelOptions() dans ce rappel.