CoreDispatcher.RunAsync(CoreDispatcherPriority, DispatchedHandler) Metodo

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

Parametri

Restituisce

Oggetto che fornisce gestori per l'invio dell'evento asincrono completato.

Attributi

RemoteAsyncAttribute

Esempio

Gli esempi seguenti illustrano l'uso di Dispatcher.RunAsync per pianificare il lavoro sul thread principale dell'interfaccia utente usando il dispatcher eventi di 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)); 
}

Commenti

Se si usa un thread di lavoro e si vuole pianificare il lavoro nel thread dell'interfaccia utente, usare CoreDispatcher.RunAsync. Impostare sempre la priorità su CoreDispatcherPriority.Normal o CoreDispatcherPriority.Low e assicurarsi che qualsiasi callback concatenato usi anche CoreDispatcherPriority.Normal o CoreDispatcherPriority.Low.

Per attivare un thread di lavoro dal thread dell'interfaccia utente, non usare questo metodo (CoreDispatcher.RunAsync). Usare invece uno degli overload del metodo Windows.System.Threading.ThreadPool.RunAsync .

Questo metodo viene completato correttamente all'avvio dell'arresto di CoreDispatcher, ma non esegue il callback specificato nel thread dell'interfaccia utente. Usare CoreDispatcher.TryRunAsync se è necessario rilevare questo caso.

C++/WinRT. Un'alternativa a CoreDispatcher.RunAsync è winrt::resume_foreground.

Attendere un'attività dell'interfaccia utente inviata da un thread in background

Quando aggiorni l'interfaccia utente da un thread in background chiamando RunAsync, pianifica il lavoro sul thread dell'interfaccia utente e restituisce immediatamente il controllo al chiamante. Se è necessario attendere il completamento del lavoro asincrono prima della restituzione, ad esempio, in attesa dell'input dell'utente in una finestra di dialogo, non usare solo RunAsync . RunAsync non consente inoltre all'attività di restituire un risultato al chiamante.

In questo esempio C# RunAsync restituisce senza attendere l'input dell'utente dalla finestra di dialogo. RunAsync restituisce non appena inizia l'esecuzione del codice nell'espressione lambda.

//DO NOT USE THIS CODE.

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

In questo caso, per C#, è necessario usare TaskCompletionSource in combinazione con RunAsync per restituire un'attività che è possibile attendere dal thread in background, sospendo l'esecuzione fino al completamento dell'attività dell'interfaccia utente.

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 non è disponibile per C++/WinRT. Per le opzioni alternative, vedere Un esempio di origine di completamento.

Conversione da .NET

Se si esegue la conversione dal codice .NET e si usano i metodi Dispatcher.BeginInvoke e Dispatcher.Invoke , si noti che CoreDispatcher.RunAsync è asincrono. Non esiste alcuna versione sincrona. Dopo aver modificato Dispatcher.Invoke in CoreDispatcher.RunAsync, il codice deve supportare il modello Windows Runtime asincrono e usare la sintassi lambda specifica per il linguaggio scelto.

Si applica a

Vedi anche

• Programmazione asincrona