CoreDispatcher.RunAsync(CoreDispatcherPriority, DispatchedHandler) Metodo

Definizione

Spazio dei nomi:

Windows.UI.Core

Pianifica il callback fornito nel thread dell'interfaccia utente da un thread di lavoro e restituisce i risultati in modo asincrono.

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

priority

CoreDispatcherPriority

Specifica la priorità per l'invio di eventi. Impostare questa proprietà su CoreDispatcherPriority.Normal.

agileCallback

DispatchedHandler

Callback su cui viene restituito il dispatcher quando viene inviato l'evento.

Restituisce

IAsyncAction

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.

Nota

I callback pianificati con CoreDispatcherPriority.Priorità bassa vengono chiamati quando non sono presenti eventi di input in sospeso. Usa la priorità CoreDispatcherPriority.Low per rendere l'interfaccia utente dell'app più reattiva. Per pianificare le attività in background, usare CoreDispatcher.RunIdleAsync.

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

Suggerimento

Per questo motivo, è consigliabile usare il metodo di estensione RunTaskAsync dalla libreria dei frammenti di attività. Offre una soluzione affidabile che consente al codice in esecuzione in un thread in background di attendere un'attività che deve essere eseguita nel thread dell'interfaccia utente. Vedere la pagina Await a UI task sent from a background thread (Attendere un'attività dell'interfaccia utente inviata da un thread in background ) per il codice e l'utilizzo di esempio.

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.

Vedi anche

• Programmazione asincrona