Sdílet prostřednictvím

Vytvoření pravidelné pracovní položky

důležitá rozhraní API

Zjistěte, jak vytvořit pracovní položku, která se pravidelně opakuje.

Vytvoření pravidelné pracovní položky

K vytvoření pravidelné pracovní položky použijte metodu CreatePeriodicTimer. Zadejte lambda, která provede práci, a pomocí parametru období určete interval mezi odesláními. Období je určeno pomocí struktury TimeSpan. Pracovní položka bude znovu odeslána při každém uplynutí období, proto se ujistěte, že je doba dostatečná pro dokončení práce.

CreateTimer vrátí objekt ThreadPoolTimer. Uložte tento objekt v případě, že je potřeba časovač zrušit.

Poznámka Vyhněte se zadání hodnoty nula (nebo jakékoli hodnoty menší než jeden milisekund) pro interval. To způsobí, že se periodický časovač bude chovat jako jednorázový časovač.

Poznámka Můžete použít CoreDispatcher.RunAsync pro přístup k uživatelskému rozhraní a zobrazení průběhu z pracovní položky.

Následující příklad vytvoří pracovní položku, která se spustí každých 60 sekund:

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

Zpracování zrušení pravidelné pracovní položky (volitelné)

V případě potřeby můžete zpracovat zrušení pravidelného časovače pomocí TimerDestroyedHandler. Pomocí přetížení metody CreatePeriodicTimer zadejte další funkci lambda, která zpracovává zrušení pravidelné pracovní položky.

Následující příklad vytvoří pravidelnou pracovní položku, která se opakuje každých 60 sekund a také poskytuje obslužnou rutinu zrušení:

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.

                }));
        }));

Zrušení časovače

V případě potřeby zavolejte metodu Zrušit, aby se periodická pracovní položka přestala opakovat. Pokud je pracovní položka spuštěna v době, kdy je periodický časovač zrušen, může se dokončit. TimerDestroyedHandler (pokud je k dispozici) se vyvolá, když jsou dokončeny všechny instance periodické pracovní položky.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Poznámky

Informace o časovači s jedním použitím naleznete v tématu Použití časovače k odeslání pracovní položky.