CoreDispatcher.RunAsync(CoreDispatcherPriority, DispatchedHandler) Método

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

Parâmetros

Retornos

O objeto que fornece manipuladores para a expedição de evento assíncrona concluída.

Atributos

RemoteAsyncAttribute

Exemplos

Os exemplos a seguir demonstram o uso de Dispatcher.RunAsync para agendar o trabalho no thread de interface do usuário main usando o dispatcher de eventos do 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)); 
}

Comentários

Se você estiver em um thread de trabalho e quiser agendar o trabalho no thread da interface do usuário, use CoreDispatcher.RunAsync. Sempre defina a prioridade como CoreDispatcherPriority.Normal ou CoreDispatcherPriority.Low e verifique se todos os retornos de chamada encadeados também usam CoreDispatcherPriority.Normal ou CoreDispatcherPriority.Low.

Para desativar um thread de trabalho do thread da interface do usuário, não use esse método (CoreDispatcher.RunAsync). Em vez disso, use uma das sobrecargas do método Windows.System.Threading.ThreadPool.RunAsync .

Esse método é concluído com êxito quando o CoreDispatcher começa a ser desligado, mas não executa o retorno de chamada especificado no thread da interface do usuário. Use CoreDispatcher.TryRunAsync se precisar detectar esse caso.

C++/WinRT. Uma alternativa ao CoreDispatcher.RunAsync é winrt::resume_foreground.

Aguardar uma tarefa de interface do usuário enviada de um thread em segundo plano

Quando você atualiza sua interface do usuário de um thread em segundo plano chamando RunAsync, ela agenda o trabalho no thread da interface do usuário e retorna o controle para o chamador imediatamente. Se você precisar aguardar a conclusão do trabalho assíncrono antes de retornar, por exemplo, aguardando a entrada do usuário em uma caixa de diálogo, não use RunAsync sozinho. RunAsync também não fornece uma maneira de a tarefa retornar um resultado para o chamador.

Neste exemplo de C#, RunAsync retorna sem aguardar a entrada do usuário da caixa de diálogo. (RunAsync retorna assim que o código na expressão lambda começa a ser executado.)

//DO NOT USE THIS CODE.

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

Nesse caso, para C#, você precisa usar um TaskCompletionSource em combinação com RunAsync para retornar uma Tarefa que você pode aguardar do thread em segundo plano, pausando assim a execução até que a tarefa de interface do usuário seja concluída.

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ão está disponível para C++/WinRT. Para obter opções alternativas, consulte Um exemplo de origem de conclusão.

Portabilidade do .NET

Se você estiver fazendo a portabilidade do código .NET e usando os métodos Dispatcher.BeginInvoke e Dispatcher.Invoke , observe que CoreDispatcher.RunAsync é assíncrono. Não há nenhuma versão síncrona. Depois de alterar Dispatcher.Invoke para CoreDispatcher.RunAsync, seu código deve dar suporte ao padrão assíncrono Windows Runtime e usar a sintaxe lambda específica para o idioma escolhido.

Aplica-se a

Confira também

• Programação assíncrona