Wie wickeln Sie Async-Callback mit Observable oder Async/warten?

Question

Ich verwende eine Netzwerk-API, die mit Rückrufen funktioniert. Also im Grunde, ich habe ein paar Methodenaufrufe, dass ich in diesem 3rd-Party-Bibliothek verwenden müssen, die wie folgt aussehen:

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

ich den Code finden ein wenig verrückt bekommen, weil alle meine Methoden, die auf Netzwerk abhängen Ressourcen von dieser 3rd Party API müssen auch Callbacks selbst implementieren. Zum Beispiel habe ich kann in meiner Haupt-Szene will die Spieler Informationen und mein Code bekommen würde wie folgt aussehen:

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

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

Ich habe vor kurzem in RX bekommen und bin mit ihm abundently in meinem Code. Ich habe gelesen, lesen Sie etwas über async/erwarten. Ich habe viel experimentiert, vor allem mit RX, und habe versucht, mit Observable.FromAsync() zu arbeiten, konnte es aber nicht zum Laufen bringen.

Was fehlt mir hier? Wie kann ich Code schreiben, der sauberer ist und den Rückruf nicht benötigt, der RX oder async verwendet/wartet? Das folgende ist der pseudedocode, den ich suche:

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

Answer 1

Ich bin nicht sicher über RX. Sie können jedoch Rückruf-basierte SendNetworkRequest zu einer awaitable Aufgabe wie folgt konvertieren:

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; 
      }); 
     } 

Jetzt können Sie SendNetworkRequestAsync verbrauchen mit Asynchron/erwarten mehr natürlich

Answer 2

Hier ist, wie es mit Rx zu tun. Ich tauschte aus Response für string nur so konnte ich kompilieren und zu testen, aber trivial .:

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

zu tauschen zurück Hier ist mein nehmen dies mit Rx auf tun.

Innerhalb der NetworkHelper Klasse hinzufügen, um dieses Verfahren:

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; 
      }); 
} 

Diese beobachtbares schafft, dass Observable.FromEvent(...).Take(1) intern verwendet einen beobachtbaren auf erwartete einen einzigen Aufruf der zum SendNetworkRequest Methode übergeben Action<Response> callback basiert.

Das einzige Problem damit ist, dass der Aufruf auf den aktuellen Thread bis zum Abschluss auftritt. Wenn Sie diesen Code wollen auf einem Hintergrund-Thread laufen, aber das Ergebnis an den aktuellen Thread zurück, dann können Sie dies tun:

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(); 
} 

So oder so würde man es so nennen:

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

Nur eine Randnotiz: Ihre DoMagicThing ist ein synchroner Anruf. In Rx ist das ein .Wait() Anruf, aber es ist besser, nur einen normalen .Subscribe zu verwenden, wenn Sie können.

---

Gemäß dem Kommentar, man könnte dies mit async:

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