CoreDispatcher.RunAsync(CoreDispatcherPriority, DispatchedHandler) Método

Definición

Espacio de nombres:

Windows.UI.Core

Programa la devolución de llamada proporcionada en el subproceso de interfaz de usuario desde un subproceso de trabajo y devuelve los resultados de forma asincrónica.

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 la prioridad para el envío de eventos. Establézcalo en CoreDispatcherPriority.Normal.

agileCallback

DispatchedHandler

Devolución de llamada en la que el distribuidor devuelve cuando se envía el evento.

Devoluciones

IAsyncAction

Objeto que proporciona controladores para el envío de eventos asincrónicos completado.

Atributos

RemoteAsyncAttribute

Ejemplos

En los ejemplos siguientes se muestra el uso de Dispatcher.RunAsync para programar el trabajo en el subproceso de interfaz de usuario principal mediante el distribuidor de eventos 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)); 
}

Comentarios

Si está en un subproceso de trabajo y desea programar el trabajo en el subproceso de interfaz de usuario, use CoreDispatcher.RunAsync. Establezca siempre la prioridad en CoreDispatcherPriority.Normal o CoreDispatcherPriority.Low y asegúrese de que las devoluciones de llamada encadenadas también usen CoreDispatcherPriority.Normal o CoreDispatcherPriority.Low.

Nota

Se llama a las devoluciones de llamada programadas con CoreDispatcherPriority.Low priority cuando no hay eventos de entrada pendientes. Usa la prioridad CoreDispatcherPriority.Low para que la interfaz de usuario de la aplicación tenga mayor capacidad de respuesta. Para programar tareas en segundo plano, use CoreDispatcher.RunIdleAsync.

Para poner en marcha un subproceso de trabajo desde el subproceso de interfaz de usuario, no use este método (CoreDispatcher.RunAsync). En su lugar, use una de las sobrecargas del método Windows.System.Threading.ThreadPool.RunAsync .

Este método se completa correctamente cuando CoreDispatcher comienza a apagarse, pero no ejecuta la devolución de llamada especificada en el subproceso de la interfaz de usuario. Use CoreDispatcher.TryRunAsync si necesita detectar este caso.

C++/WinRT. Una alternativa a CoreDispatcher.RunAsync es winrt::resume_foreground.

Esperar una tarea de interfaz de usuario enviada desde un subproceso en segundo plano

Al actualizar la interfaz de usuario desde un subproceso en segundo plano llamando a RunAsync, programa el trabajo en el subproceso de la interfaz de usuario y devuelve el control al autor de la llamada inmediatamente. Si necesita esperar a que se complete el trabajo asincrónico antes de devolver, por ejemplo, esperando la entrada del usuario en un cuadro de diálogo, no use RunAsync solo. RunAsync tampoco proporciona una manera de que la tarea devuelva un resultado al autor de la llamada.

En este ejemplo de C#, RunAsync devuelve sin esperar a la entrada del usuario desde el cuadro de diálogo. (RunAsync devuelve tan pronto como el código de la expresión lambda comienza a ejecutarse).

//DO NOT USE THIS CODE.

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

En este caso, para C#, debe usar taskCompletionSource en combinación con RunAsync para devolver una tarea que pueda esperar desde el subproceso en segundo plano, lo que pausa la ejecución hasta que se complete la tarea de interfaz de usuario.

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

Sugerencia

Se recomienda usar el método de extensión RunTaskAsync de nuestra biblioteca de fragmentos de código de tareas para esto. Proporciona una solución sólida que permite que el código que se ejecuta en un subproceso en segundo plano espere una tarea que se debe ejecutar en el subproceso de interfaz de usuario. Consulte la tarea Await a UI enviada desde una página de subproceso en segundo plano para ver el código y el uso de ejemplo.

C++/WinRT. TaskCompletionSource no está disponible para C++/WinRT. Para obtener opciones alternativas, consulte Un ejemplo de origen de finalización.

Migración desde .NET

Si va a migrar desde código .NET y usa métodos Dispatcher.BeginInvoke y Dispatcher.Invoke , tenga en cuenta que CoreDispatcher.RunAsync es asincrónico. No hay ninguna versión sincrónica. Después de cambiar Dispatcher.Invoke a CoreDispatcher.RunAsync, el código debe admitir el patrón asincrónico Windows Runtime y usar la sintaxis lambda específica para el lenguaje elegido.

Consulte también

• Programación asincrónica