CoreDispatcher.RunAsync(CoreDispatcherPriority, DispatchedHandler) Método

Definição

Namespace:

Windows.UI.Core

Agenda o retorno de chamada fornecido no thread da interface do usuário de um thread de trabalho e retorna os resultados de forma assíncrona.

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

priority

CoreDispatcherPriority

Especifica a prioridade para a expedição de eventos. Defina isso como CoreDispatcherPriority.Normal.

agileCallback

DispatchedHandler

O retorno de chamada no qual o dispatcher retorna quando o evento é despachado.

Retornos

IAsyncAction

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.

Observação

Retornos de chamada agendados com CoreDispatcherPriority.Baixa prioridade são chamados quando não há eventos de entrada pendentes. Use a prioridade CoreDispatcherPriority.Low para tornar a interface do usuário do aplicativo mais responsiva. Para agendar tarefas em segundo plano, use CoreDispatcher.RunIdleAsync.

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

Dica

Recomendamos que você use o método de extensão RunTaskAsync de nossa biblioteca de snippets de tarefa para isso. Ele fornece uma solução robusta que permite que o código em execução em um thread em segundo plano aguarde uma tarefa que deve ser executada no thread da interface do usuário. Consulte a página Aguardar uma tarefa de interface do usuário enviada de um thread em segundo plano para obter o código e o uso de exemplo.

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.

Confira também

• Programação assíncrona