CoreDispatcher.RunAsync(CoreDispatcherPriority, DispatchedHandler) Metode

Definisi

Ruang nama:

Windows.UI.Core

Menjadwalkan panggilan balik yang disediakan pada utas UI dari utas pekerja, dan mengembalikan hasilnya secara asinkron.

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

Parameter

priority

CoreDispatcherPriority

Menentukan prioritas untuk pengiriman peristiwa. Atur ini ke CoreDispatcherPriority.Normal.

agileCallback

DispatchedHandler

Panggilan balik tempat dispatcher kembali ketika peristiwa dikirim.

Mengembalikan

IAsyncAction

Objek yang menyediakan handler untuk pengiriman peristiwa asinkron yang telah selesai.

Atribut

RemoteAsyncAttribute

Contoh

Contoh berikut menunjukkan penggunaan Dispatcher.RunAsync untuk menjadwalkan pekerjaan pada utas UI utama menggunakan dispatcher peristiwa 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)); 
}

Keterangan

Jika Anda berada di utas pekerja, dan Anda ingin menjadwalkan pekerjaan pada utas UI, gunakan CoreDispatcher.RunAsync. Selalu atur prioritas ke CoreDispatcherPriority.Normal atau CoreDispatcherPriority.Low, dan pastikan bahwa setiap panggilan balik berantai juga menggunakan CoreDispatcherPriority.Normal atau CoreDispatcherPriority.Low.

Catatan

Panggilan balik yang dijadwalkan dengan CoreDispatcherPriority.Prioritas rendah dipanggil ketika tidak ada peristiwa input yang tertunda. Gunakan prioritas CoreDispatcherPriority.Low untuk membuat UI aplikasi Anda lebih responsif. Untuk menjadwalkan tugas latar belakang, gunakan CoreDispatcher.RunIdleAsync.

Untuk memutar utas pekerja dari utas UI, jangan gunakan metode ini (CoreDispatcher.RunAsync). Sebagai gantinya, gunakan salah satu metode Windows.System.Threading.ThreadPool.RunAsync kelebihan beban.

Metode ini berhasil diselesaikan ketika CoreDispatcher mulai dimatikan, tetapi tidak menjalankan panggilan balik yang ditentukan pada utas UI. Gunakan CoreDispatcher.TryRunAsync jika Anda perlu mendeteksi kasus ini.

C++/WinRT. Alternatif untuk CoreDispatcher.RunAsync adalah winrt::resume_foreground.

Menunggu tugas UI yang dikirim dari utas latar belakang

Saat Anda memperbarui UI dari utas latar belakang dengan memanggil RunAsync, UI menjadwalkan pekerjaan pada utas UI, dan segera mengembalikan kontrol ke pemanggil. Jika Anda perlu menunggu pekerjaan asinkron selesai sebelum kembali, misalnya, menunggu input pengguna dalam kotak dialog, jangan gunakan RunAsync saja. RunAsync juga tidak menyediakan cara bagi tugas untuk mengembalikan hasil kepada pemanggil.

Dalam contoh C#ini, RunAsync kembali tanpa menunggu input pengguna dari kotak dialog. (RunAsync kembali segera setelah kode dalam ekspresi lambda mulai dieksekusi.)

//DO NOT USE THIS CODE.

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

Dalam hal ini, untuk C#, Anda perlu menggunakan TaskCompletionSource dalam kombinasi dengan RunAsync untuk mengembalikan Tugas yang dapat Anda tunggu dari utas latar belakang Anda, sehingga menjeda eksekusi hingga tugas UI selesai.

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

Tip

Kami menyarankan agar Anda menggunakan metode ekstensi RunTaskAsync dari pustaka cuplikan tugas kami untuk ini. Ini menyediakan solusi yang kuat yang memungkinkan kode berjalan pada utas latar belakang untuk menunggu tugas yang harus berjalan pada utas UI. Lihat menunggu tugas UI yang dikirim dari halaman utas latar belakang untuk kode dan contoh penggunaan.

C++/WinRT. TaskCompletionSource tidak tersedia untuk C++/WinRT. Untuk opsi alternatif, lihat Sampel sumber penyelesaian.

Porting dari .NET

Jika Anda melakukan porting dari kode .NET, dan menggunakan metode Dispatcher.BeginInvoke dan Dispatcher.Invoke , perhatikan bahwa CoreDispatcher.RunAsync tidak sinkron. Tidak ada versi sinkron. Setelah Anda mengubah Dispatcher.Invoke ke CoreDispatcher.RunAsync, kode Anda harus mendukung pola asinkron Windows Runtime, dan menggunakan sintaks lambda tertentu untuk bahasa yang Anda pilih.

Lihat juga

• Pemrograman asinkron