CoreDispatcher.RunAsync(CoreDispatcherPriority, DispatchedHandler) Méthode

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

Paramètres

Retours

Objet qui fournit des gestionnaires pour la répartition d’événements asynchrones terminée.

Attributs

RemoteAsyncAttribute

Exemples

Les exemples suivants illustrent l’utilisation de Dispatcher.RunAsync pour planifier le travail sur le thread d’interface utilisateur main à l’aide du répartiteur d’événements de 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)); 
}

Remarques

Si vous utilisez un thread de travail et que vous souhaitez planifier le travail sur le thread d’interface utilisateur, utilisez CoreDispatcher.RunAsync. Définissez toujours la priorité sur CoreDispatcherPriority.Normal ou CoreDispatcherPriority.Low et assurez-vous que tous les rappels chaînés utilisent également CoreDispatcherPriority.Normal ou CoreDispatcherPriority.Low.

Pour extraire un thread de travail du thread d’interface utilisateur, n’utilisez pas cette méthode (CoreDispatcher.RunAsync). Utilisez plutôt l’une des surcharges de méthode Windows.System.Threading.ThreadPool.RunAsync .

Cette méthode se termine correctement lorsque CoreDispatcher commence à s’arrêter, mais n’exécute pas le rappel spécifié sur le thread d’interface utilisateur. Utilisez CoreDispatcher.TryRunAsync si vous devez détecter ce cas.

C++/WinRT. Une alternative à CoreDispatcher.RunAsync est winrt::resume_foreground.

Attendre une tâche d’interface utilisateur envoyée à partir d’un thread d’arrière-plan

Lorsque vous mettez à jour votre interface utilisateur à partir d’un thread d’arrière-plan en appelant RunAsync, elle planifie le travail sur le thread d’interface utilisateur et retourne immédiatement le contrôle à l’appelant. Si vous devez attendre la fin du travail asynchrone avant de retourner, par exemple, en attendant une entrée utilisateur dans une boîte de dialogue, n’utilisez pas RunAsync seul. RunAsync ne permet pas non plus à la tâche de retourner un résultat à l’appelant.

Dans cet exemple C#, RunAsync retourne sans attendre l’entrée utilisateur de la boîte de dialogue. (RunAsync retourne dès que le code de l’expression lambda commence à s’exécuter.)

//DO NOT USE THIS CODE.

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

Dans ce cas, pour C#, vous devez utiliser un TaskCompletionSource en combinaison avec RunAsync pour renvoyer une tâche que vous pouvez attendre à partir de votre thread d’arrière-plan, ce qui interrompt l’exécution jusqu’à la fin de la tâche d’interface utilisateur.

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

C++/WinRT. TaskCompletionSource n’est pas disponible pour C++/WinRT. Pour obtenir d’autres options, consultez Exemple de source d’achèvement.

Portage à partir de .NET

Si vous effectuez un portage à partir de code .NET et que vous utilisez les méthodes Dispatcher.BeginInvoke et Dispatcher.Invoke , notez que CoreDispatcher.RunAsync est asynchrone. Il n’existe aucune version synchrone. Après avoir changé Dispatcher.Invoke en CoreDispatcher.RunAsync, votre code doit prendre en charge le modèle asynchrone Windows Runtime et utiliser la syntaxe lambda spécifique pour le langage choisi.

S’applique à

Voir aussi

• Programmation asynchrone