Richtiger Weg, um den CoreDispatcher in einer Windows Store-App zu erhalten

Ich erstelle eine Windows Store-App und habe Code, der im UI-Thread veröffentlicht werden muss.

Dafür möchte ich den CoreDispatcher abrufen und zum Posten des Codes verwenden.

Es scheint, dass es dafür einige Möglichkeiten gibt:

// First way
Windows.ApplicationModel.Core.CoreApplication.GetCurrentView().CoreWindow.Dispatcher;

// Second way
Window.Current.Dispatcher;

Ich frage mich, welches richtig ist? oder ob beide gleichwertig sind?

Dies ist der bevorzugte Weg:

Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
    // Your UI update code goes here!
});

Dies hat den Vorteil, dass es die Hauptleitung erhält CoreApplicationViewund somit immer verfügbar ist. Weitere Details hier .

Es gibt zwei Alternativen, die Sie verwenden können.

Erste Alternative

Windows.ApplicationModel.Core.CoreApplication.GetCurrentView().CoreWindow.Dispatcher

Dadurch wird die aktive Ansicht für die App abgerufen, Sie erhalten jedoch null , wenn keine Ansichten aktiviert wurden. Weitere Details hier .

Zweite Alternative

Window.Current.Dispatcher

Diese Lösung funktioniert nicht, wenn sie von einem anderen Thread aufgerufen wird, da sie anstelle des UI-Dispatchers null zurückgibt . Weitere Details hier .

Für alle, die C ++ / CX verwenden

Windows::ApplicationModel::Core::CoreApplication::MainView->CoreWindow->Dispatcher->RunAsync(
    CoreDispatcherPriority::Normal,
    ref new Windows::UI::Core::DispatchedHandler([this]()
{
    // do stuff
}));

await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
            CoreDispatcherPriority.Normal,
            () => { // your code should be here});

Obwohl dies ein alter Thread ist, wollte ich auf ein mögliches Problem aufmerksam machen, auf das Entwickler stoßen könnten, das mich betroffen hat und das Debuggen in großen UWP-Apps äußerst schwierig machte. In meinem Fall habe ich den folgenden Code aus den obigen Vorschlägen im Jahr 2014 überarbeitet, wurde jedoch gelegentlich von gelegentlichen zufälligen Einfrierungen der App geplagt.

public static class DispatcherHelper
{
    public static Task RunOnUIThreadAsync(Action action)
    {
        return RunOnUIThreadAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, action);
    }

    public static async Task RunOnUIThreadAsync(Windows.UI.Core.CoreDispatcherPriority priority, Action action)
    {
        try
        {
            await returnDispatcher().RunAsync(priority, () =>
            {
                action();
            });
        }
        catch (Exception ex)
        {
            var noawait = ExceptionHandler.HandleException(ex, false);
        }
    }

    private static Windows.UI.Core.CoreDispatcher returnDispatcher()
    {
        return (Windows.UI.Xaml.Window.Current == null) ?
            CoreApplication.MainView.CoreWindow.Dispatcher :
            CoreApplication.GetCurrentView().CoreWindow.Dispatcher;
    }
}

Aus dem oben Gesagten hatte ich eine statische Klasse verwendet, um den Aufruf des Dispatchers in der gesamten Anwendung zu ermöglichen - wobei ein einzelner Aufruf möglich war. In 95% der Fälle war auch durch QS-Regression alles in Ordnung, aber Kunden meldeten ab und zu ein Problem. Die Lösung bestand darin, den folgenden Aufruf einzuschließen und keinen statischen Aufruf auf den tatsächlichen Seiten zu verwenden.

            await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            { 

            });

Dies ist nicht der Fall, wenn ich sicherstellen muss, dass der UI-Thread von App.xaml.cs oder meinem Singleton NavigationService aufgerufen wurde, der das Pushing / Popping auf den Stack handhabte. Der Dispatcher verlor anscheinend den Überblick darüber, welcher UI-Thread aufgerufen wurde, da jede Seite einen eigenen UI-Thread hat, wenn auf dem Stack verschiedene Nachrichten vom MessageBus ausgelöst wurden.

Ich hoffe, dies hilft anderen, die möglicherweise betroffen sind, und ich denke, dass jede Plattform ihren Entwicklern einen Service bieten würde, indem sie ein vollständiges Projekt veröffentlicht, das die Best Practices abdeckt.

Eigentlich würde ich etwas in dieser Richtung vorschlagen:

return (Window.Current == null) ? 
    CoreApplication.MainView.CoreWindow.Dispatcher : 
    CoreApplication.GetCurrentView().CoreWindow.Dispatcher

Auf diese Weise werden die Dispatcher nicht verwirrt, wenn Sie eine andere Ansicht / ein anderes Fenster geöffnet haben ...

Dieses kleine Juwel prüft, ob es überhaupt ein Fenster gibt. Wenn keine vorhanden ist, verwenden Sie den Dispatcher von MainView. Wenn es eine Ansicht gibt, verwenden Sie den Dispatcher.