Silverlight Async Méthode Chaînage (Gotchas possibles?)

Question

Je travaille sur un projet Silverlight 4 'proof of concept' et j'apprends le chemin de l'ASYNC. J'ai arrêté de combattre l'envie de mettre en place une technique pseudo-synchrone de fumée et de miroirs. Je vais apprendre à cesser de m'inquiéter et à aimer l'ASYNC.

La plupart du temps, j'utilise simplement un BusyIndicator alors que les méthodes async sont en cours d'exécution et tout est bon, mais j'ai rencontré quelques situations où j'ai besoin d'appeler des méthodes séquentiellement. J'ai rassemblé cet exemple et cela fonctionne. Mais d'après mon expérience ... si ça marche ... il y a quelque chose qui ne va pas.

Quand est-ce que ça va me sauter au visage ou voler ma femme ou sortir avec une de mes filles? Y a-t-il une meilleure façon de faire cela?

Le code:

public class CustomPage : Page 
{ 
    static readonly object _AsyncMethodChain_Lock = new object(); 
    private Dictionary<Action<object>, string> _AsyncMethodChain = new Dictionary<Action<object>, string>(); 

    public Dictionary<Action<object>, string> AsyncMethodChain 
    { 
     get { lock (_AsyncMethodChain_Lock) { return this._AsyncMethodChain; } } 
     set { lock (_AsyncMethodChain_Lock) { this._AsyncMethodChain = value; } } 
    } 

    private void CustomPage_Loaded(object sender, RoutedEventArgs e) 
    { 
     if (!System.ComponentModel.DesignerProperties.GetIsInDesignMode(this)) 
     { 
      var user = this.SecurityProvider.UserObject as TimeKeeper.UserServiceReference.User; 

      if (user == null) 
       return; 

      this.AsyncMethodChain.Add(
       data => 
       { 
        var userServiceClient = new UserServiceClient(); 
        userServiceClient.GetCompleted += 
         (send, arg) => 
         { 
          var userViewSource = this.Resources["userViewSource"] as CollectionViewSource; 
          userViewSource.Source = new List<UserServiceReference.User>(new UserServiceReference.User[1] { arg.Result }); 
          userViewSource.View.MoveCurrentToPosition(0); 
          this.AsyncMethodChain.ExecuteNext(arg.Result.UserID, this.BusyIndicator); 
         }; 
        userServiceClient.GetAsync(user.UserID); 
       }, 
       "Loading user..." 
       ); 

      this.AsyncMethodChain.Add(
       data => 
       { 
        var userID = (int)data; 
        var timeLogServiceClient = new TimeLogServiceClient(); 
        timeLogServiceClient.FindByUserIDCompleted += 
         (send, arg) => 
         { 
          var timeLogViewSource = this.Resources["timeLogViewSource"] as CollectionViewSource; 
          timeLogViewSource.Source = arg.Result; 
          this.AsyncMethodChain.ExecuteNext(null, this.BusyIndicator); 
         }; 
        timeLogServiceClient.FindByUserIDAsync(userID); 
       }, 
       "Loading time logs..." 
       ); 

      this.AsyncMethodChain.ExecuteNext(null, this.BusyIndicator); 
     } 
    } 
} 

public static class Extensions 
{ 
    public static void ExecuteNext(this Dictionary<Action<object>, string> methods, object data, BusyIndicator busyIndicator) 
    { 
     if (methods.Count <= 0) 
     { 
      busyIndicator.BusyContent = ""; 
      busyIndicator.IsBusy = false; 
      return; 
     } 
     else 
     { 
      var method = methods.Keys.ToList<Action<object>>()[0]; 
      busyIndicator.BusyContent = methods[method]; 
      busyIndicator.IsBusy = true; 
     } 

     methods.ExecuteNext(data); 
    } 

    public static void ExecuteNext(this Dictionary<Action<object>, string> methods, object data) 
    { 
     var method = methods.Keys.ToList<Action<object>>()[0]; 
     methods.Remove(method); 
     method(data); 
    } 
} 

Answer 1

Qu'est-ce que vous avez sinus semble assez bon, mais si vous êtes toujours inquiet au sujet de la callsequence je sugest que vous créez une nouvelle méthode dans votre webservice qui appellera les quatre autres en quelle que soit la séquence dont vous avez besoin et appelez cette nouvelle méthode depuis votre application Silverlight.

Je ne vois pas le besoin de faire cela car votre implémentation actuelle est plutôt bonne.