CoreDispatcher.RunAsync(CoreDispatcherPriority, DispatchedHandler) Methode

Definition

Namespace:

Windows.UI.Core

Plant den bereitgestellten Rückruf für den UI-Thread aus einem Workerthread und gibt die Ergebnisse asynchron zurück.

public:
 virtual IAsyncAction ^ RunAsync(CoreDispatcherPriority priority, DispatchedHandler ^ agileCallback) = RunAsync;

/// [Windows.Foundation.Metadata.RemoteAsync]
IAsyncAction RunAsync(CoreDispatcherPriority const& priority, DispatchedHandler const& agileCallback);

[Windows.Foundation.Metadata.RemoteAsync]
public IAsyncAction RunAsync(CoreDispatcherPriority priority, DispatchedHandler agileCallback);

function runAsync(priority, agileCallback)

Public Function RunAsync (priority As CoreDispatcherPriority, agileCallback As DispatchedHandler) As IAsyncAction

Parameter

priority

CoreDispatcherPriority

Gibt die Priorität für die Ereignisverteilung an. Legen Sie dies auf CoreDispatcherPriority.Normal fest.

agileCallback

DispatchedHandler

Der Rückruf, den der Verteiler zurückgibt, wenn das Ereignis verteilt wird.

Gibt zurück

IAsyncAction

Das -Objekt, das Handler für die abgeschlossene asynchrone Ereignisverteilung bereitstellt.

Attribute

RemoteAsyncAttribute

Beispiele

Die folgenden Beispiele veranschaulichen die Verwendung von Dispatcher.RunAsync zum Planen der Arbeit am Standard UI-Thread mithilfe des Ereignisverteilers von CoreWindow.

await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
   rootPage.NotifyUser("The toast encountered an error", NotifyType.ErrorMessage);
});

var ignored = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
   Scenario3OutputText.Text += outputText;
});

TimerTextBlock().Dispatcher().RunAsync(Windows::UI::Core::CoreDispatcherPriority::Normal, [=]()
{
    ++m_count;
    std::wstringstream wstringstream;
    wstringstream << L"Total count: " << m_count;
    TimerTextBlock().Text(wstringstream.str().c_str());
});

// 
_Dispatcher->RunAsync(Windows::UI::Core::CoreDispatcherPriority::Normal, 
                     ref new Windows::UI::Core::DispatchedHandler([this]()
{
  _count++;
  TimerTextBlock->Text = "Total Running Time: " + _count.ToString() + " Seconds";
}));

// using CallbackContext::Any
void Playback::DisplayStatus(Platform::String^ text)
{
  _Dispatcher->RunAsync(Windows::UI::Core::CoreDispatcherPriority::Normal, 
                        ref new Windows::UI::Core::DispatchedHandler([=]()
  {
    _OutputStatus->Text += text + "\n";
  }, CallbackContext::Any)); 
}

Hinweise

Wenn Sie in einem Workerthread arbeiten und die Arbeit im UI-Thread planen möchten, verwenden Sie CoreDispatcher.RunAsync. Legen Sie die Priorität immer auf CoreDispatcherPriority.Normal oder CoreDispatcherPriority.Low fest, und stellen Sie sicher, dass alle verketteten Rückrufe auch CoreDispatcherPriority.Normal oder CoreDispatcherPriority.Low verwenden.

Hinweis

Rückrufe, die mit der Priorität CoreDispatcherPriority.Low geplant sind, werden aufgerufen, wenn keine Eingabeereignisse ausstehen. Verwenden Sie die CoreDispatcherPriority.Low-Priorität , um die App-Benutzeroberfläche reaktionsfähiger zu gestalten. Verwenden Sie Zum Planen von Hintergrundaufgaben CoreDispatcher.RunIdleAsync.

Verwenden Sie diese Methode (CoreDispatcher.RunAsync) nicht, um einen Workerthread aus dem UI-Thread auszugliedern. Verwenden Sie stattdessen eine der Windows.System.Threading.ThreadPool.RunAsync-Methodenüberladungen .

Diese Methode wird erfolgreich abgeschlossen, wenn coreDispatcher heruntergefahren wird, führt jedoch nicht den angegebenen Rückruf im UI-Thread aus. Verwenden Sie CoreDispatcher.TryRunAsync , wenn Sie diesen Fall erkennen müssen.

C++/WinRT. Eine Alternative zu CoreDispatcher.RunAsync ist winrt::resume_foreground.

Warten einer UI-Aufgabe, die von einem Hintergrundthread gesendet wird

Wenn Sie Die Benutzeroberfläche von einem Hintergrundthread aus aktualisieren, indem Sie RunAsync aufrufen, wird die Arbeit im UI-Thread geplant und die Steuerung sofort an den Aufrufer zurückgegeben. Wenn Sie warten müssen, bis die asynchrone Arbeit abgeschlossen ist, bevor Sie zurückgegeben werden, z. B. auf Benutzereingaben in einem Dialogfeld warten, verwenden Sie RunAsync nicht allein. RunAsync bietet auch keine Möglichkeit für den Task, ein Ergebnis an den Aufrufer zurückzugeben.

In diesem C#-Beispiel gibt RunAsync zurück, ohne auf die Benutzereingabe aus dem Dialogfeld zu warten. (RunAsync gibt zurück, sobald der Code im Lambdaausdruck mit der Ausführung beginnt.)

//DO NOT USE THIS CODE.

await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
{
   await signInDialog.ShowAsync(); 
});
// Execution continues here before the call to ShowAsync completes.

In diesem Fall müssen Sie für C# eine TaskCompletionSource in Kombination mit RunAsync verwenden, um einen Task zurückzugeben, den Sie von Ihrem Hintergrundthread erwarten können, wodurch die Ausführung angehalten wird, bis die Ui-Aufgabe abgeschlossen ist.

public async Task<ContentDialogResult> SignInAsync()
{
    TaskCompletionSource<ContentDialogResult> taskCompletionSource = 
        new TaskCompletionSource<ContentDialogResult>();

    await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
    {
        try
        {
            taskCompletionSource.SetResult(await signInDialog.ShowAsync());
        }
        catch (Exception ex)
        {
            taskCompletionSource.SetException(ex);
        }
    });

    return await taskCompletionSource.Task;
}

Tipp

Es wird empfohlen, dafür die Erweiterungsmethode RunTaskAsync aus unserer Aufgabenausschnittbibliothek zu verwenden. Es bietet eine robuste Lösung, die es code, der in einem Hintergrundthread ausgeführt wird, ermöglicht, auf eine Aufgabe zu warten, die im UI-Thread ausgeführt werden muss. Den Code und die Beispielverwendung finden Sie unter Warten einer Ui-Aufgabe, die von einem Hintergrundthread gesendet wird .

C++/WinRT. TaskCompletionSource ist für C++/WinRT nicht verfügbar. Alternative Optionen finden Sie unter Beispiel für eine Vervollständigungsquelle.

Portieren von .NET

Wenn Sie aus .NET-Code portieren und die Methoden Dispatcher.BeginInvoke und Dispatcher.Invoke verwenden, beachten Sie, dass CoreDispatcher.RunAsync asynchron ist. Es gibt keine synchrone Version. Nachdem Sie Dispatcher.Invoke in CoreDispatcher.RunAsync geändert haben, muss Ihr Code das Windows-Runtime asynchrones Muster unterstützen und die spezifische Lambdasyntax für die ausgewählte Sprache verwenden.

Weitere Informationen

• Asynchrone Programmierung