Comment faire pour encapsuler le rappel asynchrone avec Observable ou async/await?

Question

J'utilise une API réseau qui fonctionne avec les rappels. Donc, fondamentalement, j'ai un tas appels de méthode que je dois utiliser dans cette bibliothèque 3ème partie qui ressemble à ceci:

void SendNetworkRequest(string requestType, Action<Response> callback) 

Je trouve le code d'obtenir un peu loufoque parce que toutes mes méthodes qui dépendent du réseau Les ressources de cette API tierce doivent également implémenter des rappels eux-mêmes. Par exemple, dans ma scène principale je veux obtenir les informations des joueurs et mon code ressemblerait à quelque chose comme ceci:

void InitMainScene() 
{ 
     _networkHelper.SendNetworkRequest("GetPlayersInfo",OnPlayerInfoResponse); 
} 

void OnPlayerInfoResponse(Response response) 
{ 
    _playerInfo = response.Info; 
} 

J'ai récemment obtenu en RX et je l'utilise abundently dans mon code. J'ai lu en lire un peu sur async/await. J'ai beaucoup expérimenté, surtout avec RX, et j'ai essayé de travailler avec Observable.FromAsync() mais je n'ai pas pu le faire fonctionner.

Qu'est-ce qui me manque ici? Comment est-ce que je peux écrire le code qui est plus propre et n'exige pas le rappel utilisant le RX ou l'async/l'attente? Ce qui suit est le psuedocode que je suis à la recherche:

 void InitMainScene() 
     { 
      _playerInfo = Overservable.DoMagicThing<Response>(() => { 
_networkHelper.SendNetworkRequest("GetPlayersInfo",(r) =>{return r;}); }); 
     } 

Answer 1

Je ne suis pas sûr de RX. Cependant, vous pouvez convertir SendNetworkRequest à base de rappel à une tâche awaitable comme ceci:

void SendNetworkRequest(string requestType, Action<Response> callback) 
     { 
      // This code by third party, this is here just for testing 
      if (callback != null) 
      { 
       var result = new Response(); 
       callback(result); 
      } 
     } 

     Task<Response> SendNetworkRequestAsync(string requestType) 
     { 
      return Task.Run(() => 
      { 
       var t = new TaskCompletionSource<Response>(); 

       SendNetworkRequest(requestType, s => t.TrySetResult(s)); 

       return t.Task; 
      }); 
     } 

Maintenant, vous pouvez consommer SendNetworkRequestAsync avec async/attendre plus naturellement

Answer 2

Voici comment faire avec Rx. Je troqué Response pour string juste pour pouvoir compiler et tester, mais trivial d'échanger arrière .:

public IObservable<string> SendNetworkRequestObservable(string requestType) 
{ 
    return Observable.Create<string>(observer => 
    { 
     SendNetworkRequest(requestType, s => observer.OnNext(s)); 
     observer.OnCompleted(); 
     return Disposable.Empty; 
    }); 
} 

// Define other methods and classes here 
public void SendNetworkRequest(string requestType, Action<string> callback) 
{ 
    callback(requestType); // implementation for testing purposes 
} 

Answer 3

Voici mon avis sur le faire avec Rx.

Dans la classe NetworkHelper ajouter cette méthode:

public IObservable<Response> SendNetworkRequestObservable(string requestType) 
{ 
    return 
     Observable 
      .Create<Response>(observer => 
      { 
       Action<Response> callback = null; 
       var callbackQuery = 
        Observable 
         .FromEvent<Response>(h => callback += h, h => callback -= h) 
         .Take(1); 
       var subscription = callbackQuery.Subscribe(observer); 
       this.SendNetworkRequest(requestType, callback); 
       return subscription; 
      }); 
} 

Cela crée une observable qui utilise en interne Observable.FromEvent(...).Take(1) pour créer une observable sur la base attend un seul appel à la Action<Response> callback transmis à la méthode SendNetworkRequest.

Le seul problème avec ceci est que l'appel se produit sur le thread en cours jusqu'à la fin. Si vous voulez que ce code à exécuter sur un thread d'arrière-plan, mais renvoie le résultat au thread courant, vous pouvez le faire:

public IObservable<Response> SendNetworkRequestObservable(string requestType) 
{ 
    return 
     Observable 
      .Start(() => 
       Observable 
        .Create<Response>(observer => 
        { 
         Action<Response> callback = null; 
         var callbackQuery = 
          Observable 
           .FromEvent<Response>(h => callback += h, h => callback -= h) 
           .Take(1); 
         var subscription = callbackQuery.Subscribe(observer); 
         this.SendNetworkRequest(requestType, callback); 
         return subscription; 
        })) 
      .Merge(); 
} 

Quoi qu'il en soit vous appelleriez comme ceci:

var _playerInfo = 
    _networkHelper 
     .SendNetworkRequestObservable("GetPlayersInfo") 
     .Wait(); 

Juste une note: votre DoMagicThing est un appel synchrone. En Rx c'est un appel .Wait(), mais il est préférable d'utiliser un .Subscribe normal quand vous le pouvez.

---

Selon le commentaire, vous pouvez le faire avec async:

async void InitMainScene() 
{ 
    _playerInfo = await _networkHelper.SendNetworkRequestObservable("GetPlayersInfo"); 
}