Bagikan melalui

Membuat item kerja berkala

  • Artikel

API penting

Pelajari cara membuat item kerja yang berulang secara berkala.

Membuat item kerja berkala

Gunakan metode CreatePeriodicTimer untuk membuat item kerja berkala. Berikan lambda yang menyelesaikan pekerjaan, dan gunakan parameter periode untuk menentukan interval antara pengiriman. Periode ditentukan menggunakan struktur TimeSpan. Item kerja akan dikirim ulang setiap kali periode berlalu, jadi pastikan periode cukup lama untuk pekerjaan selesai.

CreateTimer mengembalikan objek ThreadPoolTimer . Simpan objek ini jika timer perlu dibatalkan.

Catatan Hindari menentukan nilai nol (atau nilai apa pun kurang dari satu milidetik) untuk interval. Ini menyebabkan timer berkala bereaksi sebagai timer satu bidikan sebagai gantinya.

Catatan Anda dapat menggunakan CoreDispatcher.RunAsync untuk mengakses UI dan menampilkan kemajuan dari item kerja.

Contoh berikut membuat item kerja yang berjalan setiap 60 detik sekali:

TimeSpan period = TimeSpan.FromSeconds(60);

ThreadPoolTimer PeriodicTimer = ThreadPoolTimer.CreatePeriodicTimer((source) =>
    {
        //
        // TODO: Work
        //
        
        //
        // Update the UI thread by using the UI core dispatcher.
        //
        Dispatcher.RunAsync(CoreDispatcherPriority.High,
            () =>
            {
                //
                // UI components can be accessed within this scope.
                //

            });

    }, period);

TimeSpan period;
period.Duration = 60 * 10000000; // 10,000,000 ticks per second

ThreadPoolTimer ^ PeriodicTimer = ThreadPoolTimer::CreatePeriodicTimer(
        ref new TimerElapsedHandler([this](ThreadPoolTimer^ source)
        {
            //
            // TODO: Work
            //
            
            //
            // Update the UI thread by using the UI core dispatcher.
            //
            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([this]()
                {
                    //
                    // UI components can be accessed within this scope.
                    //
                        
                }));

        }), period);

Menangani pembatalan item kerja berkala (opsional)

Jika diperlukan, Anda dapat menangani pembatalan timer berkala dengan TimerDestroyedHandler. Gunakan overload CreatePeriodicTimer untuk menyediakan lambda tambahan yang menangani pembatalan item kerja berkala.

Contoh berikut membuat item kerja berkala yang berulang setiap 60 detik dan juga menyediakan handler pembatalan:

using Windows.System.Threading;

    TimeSpan period = TimeSpan.FromSeconds(60);

    ThreadPoolTimer PeriodicTimer = ThreadPoolTimer.CreatePeriodicTimer((source) =>
    {
        //
        // TODO: Work
        //
        
        //
        // Update the UI thread by using the UI core dispatcher.
        //
        Dispatcher.RunAsync(CoreDispatcherPriority.High,
            () =>
            {
                //
                // UI components can be accessed within this scope.
                //

            });
    },
    period,
    (source) =>
    {
        //
        // TODO: Handle periodic timer cancellation.
        //

        //
        // Update the UI thread by using the UI core dispatcher.
        //
        Dispatcher->RunAsync(CoreDispatcherPriority.High,
            ()=>
            {
                //
                // UI components can be accessed within this scope.
                //                 

                // Periodic timer cancelled.

            }));
    });

using namespace Windows::System::Threading;
using namespace Windows::UI::Core;

TimeSpan period;
period.Duration = 60 * 10000000; // 10,000,000 ticks per second

ThreadPoolTimer ^ PeriodicTimer = ThreadPoolTimer::CreatePeriodicTimer(
        ref new TimerElapsedHandler([this](ThreadPoolTimer^ source)
        {
            //
            // TODO: Work
            //
                
            //
            // Update the UI thread by using the UI core dispatcher.
            //
            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([this]()
                {
                    //
                    // UI components can be accessed within this scope.
                    //

                }));

        }),
        period,
        ref new TimerDestroyedHandler([&](ThreadPoolTimer ^ source)
        {
            //
            // TODO: Handle periodic timer cancellation.
            //

            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([&]()
                {
                    //
                    // UI components can be accessed within this scope.
                    //

                    // Periodic timer cancelled.

                }));
        }));

Batalkan timer

Jika perlu, panggil metode Batal untuk menghentikan item kerja berkala agar tidak diulang. Jika item kerja berjalan saat timer berkala dibatalkan, item tersebut diizinkan untuk menyelesaikannya. TimerDestroyedHandler (jika disediakan) dipanggil ketika semua instans item kerja berkala telah selesai.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Keterangan

Untuk informasi tentang timer penggunaan tunggal, lihat Menggunakan timer untuk mengirimkan item kerja.