CoreDispatcher.RunAsync(CoreDispatcherPriority, DispatchedHandler) Méthode

Définition

Espace de noms:

Windows.UI.Core

Planifie le rappel fourni sur le thread d’interface utilisateur à partir d’un thread de travail et retourne les résultats de manière asynchrone.

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

priority

CoreDispatcherPriority

Spécifie la priorité pour la répartition des événements. Définissez cette valeur sur CoreDispatcherPriority.Normal.

agileCallback

DispatchedHandler

Rappel sur lequel le répartiteur retourne lorsque l’événement est distribué.

Retours

IAsyncAction

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.

Notes

Les rappels planifiés avec CoreDispatcherPriority.Low priority sont appelés lorsqu’aucun événement d’entrée n’est en attente. Utilisez la priorité CoreDispatcherPriority.Low pour rendre l’interface utilisateur de votre application plus réactive. Pour planifier des tâches en arrière-plan, utilisez CoreDispatcher.RunIdleAsync.

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

Conseil

Pour cela, nous vous recommandons d’utiliser la méthode d’extension RunTaskAsync de notre bibliothèque d’extraits de tâches. Il fournit une solution robuste qui permet au code en cours d’exécution sur un thread d’arrière-plan d’attendre une tâche qui doit s’exécuter sur le thread d’interface utilisateur. Consultez la page Attendre une tâche d’interface utilisateur envoyée à partir d’un thread d’arrière-plan pour le code et l’exemple d’utilisation.

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.

Voir aussi

• Programmation asynchrone