Universal Windows, C#, erwarten während App-Initialisierung

Question

Ich versuche, eine einfache App, die ich auf Windows Phone 8 auf Universal Windows ausgeführt hatte, zu portieren. Ich habe ein paar Dateien, die ich (lokal) laden muss, bevor ich den Hauptrahmen/die Haupseite erstelle, da diese anweisen, wie man die Seite an erster Stelle erstellt. Es gibt eine .XML- und einige Inhaltsdateien, die Teil von Assets sind.

Ich habe die Initialisierung während der App.Application_Launching() durchgeführt, die ich jetzt denke, wird von App.OnLaunched() ersetzt. Das Problem liegt in der neuen asynchronen Datei-IO. Ich kann keinen Ort finden, an dem ich Async-APIs aufrufen kann, ohne dass das Programm hängen bleibt. Es scheint, dass irgendwo in App.OnLaunched(), MainPage.MainPage(), MainPage.OnNavigatedTo() usw. kann ich nicht erwarten.

Ich muss im Grunde ein Hintergrund-Thread abfeuern, um eine Aufgabe zu planen, die später ausgeführt wird, um die eigentliche Initialisierung auszuführen, und dann zurück in den MainPage-Pool zu rufen, um etwas korrekt auszuführen. Der resultierende Code sieht ungefähr wie folgt aus. Scheint übermäßig komplex, aber ich denke, das ist richtig?

Danke, Nick.

public partial class MainPage : Page 
{ 
    // Constructor 
    public MainPage() 
    { 
     InitializeComponent(); 

     // This doesn't work ... 
     // var task = InitAsync(); 
     // task.Wait() 


     // This seems to ... 
     IAsyncAction asyncAction = ThreadPool.RunAsync((workItem) => 
     { 
      var ignored = Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,() => 
      { 
       TryInitAsync(); 
      }); 

     }); 

    } 

    private async void TryInitAsync() 
    { 
     try 
     { 
      await InitAsync(); 
     } 
     catch 
     { 
      int foo = 0; 
     } 
    } 

    private async Task<Boolean> InitAsync() 
    { 
     // Things that go await in the night 

     // Other things that update the layout 

     return true; 
    } 
} 

Answer 1

scheint zu komplex, aber ich denke, das ist richtig?

Nein, das würde ich nicht sagen.

Ich kann keinen konkreten Hinweis zur Initialisierung selbst geben, da diese Angaben in Ihrer Frage fehlen. Die grundlegende Strategie besteht darin, dass die Benutzeroberfläche nicht initialisierte Daten toleriert und die Initialisierung asynchron ausführt und die Eigenschaften nach Bedarf aktualisiert.

Soweit Ihre spezifischen Mittel zum Starten der asynchronen Initialisierung gehen, haben Sie es komplizierter gemacht, als es sein muss oder sollte. Dies wäre besser:

public MainPage() 
{ 
    InitializeComponent(); 

    var ignored = Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow 
     .Dispatcher.RunAsync(CoreDispatcherPriority.Normal,() => TryInitAsync()); 
} 

I.e. Es ist nicht erforderlich, eine Hintergrundaufgabe mit ThreadPool.RunAsync() zu starten, wenn Sie lediglich den Aufruf der Methode TryInitAsync() aufschieben und ihn auf dem UI-Thread aufrufen.

Wenn Sie dies (oder Ihren komplizierteren Weg) tun, blockieren Sie dennoch den UI-Thread. Es wäre sogar besser, nichtDispatcher.RunAsync() zu verwenden. Stattdessen tun Anruf TryInitAsync() direkt von einem Hintergrund-Task (z. B. rufen Sie es mit ThreadPool.RunAsync()) und haben die UI-gebundenen Eigenschaften abhängig von der Initialisierung aktualisiert asynchron während der Initialisierung fortschreitet.

Answer 2

Es scheint, dass irgendwo in App.OnLaunched(), MainPage.MainPage(), MainPage.OnNavigatedTo() usw. kann ich nicht erwarten.

Der Kern konzeptionelle Veränderung ist, dass moderne Anwendungen Muss zeigen eine Art von UI sofort (die synchron bedeutet). Aus diesem Grund können Sie I/O beim Start nicht ausführen.

So haben Sie darüber nachdenken, was Ihre App wie aussehen sollten, bevor es alle Dateien lädt, zeigen diesen Zustand sofort und auch asynchronen Laden Ihres „echten“ UI starten.

könnten Sie rufen TryInitAsync direkt von Ihrem Konstruktor:

public MainPage() 
{ 
    InitializeComponent(); 
    TryInitAsync(); 
} 

Oder, wenn Sie Ihre UI mit Datenbindung aktualisieren, können Sie meine verwenden NotifyTask<T> type:

public NotifyTask<InitData> Data { get; } 
public MainPage() 
{ 
    InitializeComponent(); 
    Data = NotifyTask.Create(InitAsync()); 
} 
private async Task<InitData> InitAsync() { ... } 

Und dann können Sie Datenbindung an Data.Result um InitData oder Data.IsCompleted/Data.IsNotCompleted zu erhalten, um den ursprünglichen "loading ..." Status anzuzeigen/auszublenden.