Sdílet prostřednictvím

Odeslání pracovní položky pomocí časovače

důležitá rozhraní API

Zjistěte, jak vytvořit pracovní položku, která se spustí po uplynutí časovače.

Vytvořte jednorázový časovač

Pomocí metody CreateTimer vytvořte časovač pro pracovní položku. Poskytněte lambda, která provede práci, a pomocí parametru zpoždění určete, jak dlouho má fond vláken čekat, než může pracovní položku přiřadit dostupnému vláknu. Zpoždění se zadává pomocí struktury TimeSpan.

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í za tři minuty:

TimeSpan delay = TimeSpan.FromMinutes(3);
            
ThreadPoolTimer DelayTimer = ThreadPoolTimer.CreateTimer(
    (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.
                //

            });

    }, delay);

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

ThreadPoolTimer ^ DelayTimer = ThreadPoolTimer::CreateTimer(
        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.
                    //

                    ExampleUIUpdateMethod("Timer completed.");

                }));

        }), delay);

Poskytnout obslužnou rutinu pro dokončení

V případě potřeby zpracujte zrušení a dokončení pracovní položky pomocí TimerDestroyedHandler. Pomocí přetížení CreateTimer poskytněte další lambda. Spustí se při zrušení časovače nebo po dokončení pracovní položky.

Následující příklad vytvoří časovač, který odešle pracovní položku a zavolá metodu, když pracovní položka skončí nebo časovač je zrušen:

TimeSpan delay = TimeSpan.FromMinutes(3);
            
bool completed = false;

ThreadPoolTimer DelayTimer = ThreadPoolTimer.CreateTimer(
    (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.
                    //

                });

        completed = true;
    },
    delay,
    (source) =>
    {
        //
        // TODO: Handle work cancellation/completion.
        //


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

                if (completed)
                {
                    // Timer completed.
                }
                else
                {
                    // Timer cancelled.
                }

            });
    });

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

completed = false;

ThreadPoolTimer ^ DelayTimer = ThreadPoolTimer::CreateTimer(
        ref new TimerElapsedHandler([&](ThreadPoolTimer ^ source)
        {
            //
            // TODO: Work
            //

            //
            // Update the UI thread by using the UI core dispatcher.
            //
            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([&]()
                {
                    //
                    // UI components can be accessed within this scope.
                    //

                }));

            completed = true;

        }),
        delay,
        ref new TimerDestroyedHandler([&](ThreadPoolTimer ^ source)
        {
            //
            // TODO: Handle work cancellation/completion.
            //

            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([&]()
                {
                    //
                    // Update the UI thread by using the UI core dispatcher.
                    //

                    if (completed)
                    {
                        // Timer completed.
                    }
                    else
                    {
                        // Timer cancelled.
                    }

                }));
        }));

Zrušení časovače

Pokud časovač stále odpočítává, ale úkol už není potřebný, zavolejte Zrušit. Časovač je zrušen a pracovní položka nebude odeslána do fondu vláken.

DelayTimer.Cancel();

DelayTimer->Cancel();

Poznámky

Aplikace pro Univerzální platformu Windows (UPW) nemůžou používat Thread.Sleep, protože můžou blokovat vlákno uživatelského rozhraní. Místo toho můžete k vytvoření pracovní položky použít ThreadPoolTimer, což zpozdí úlohu provedenou pracovní položkou bez blokování vlákna uživatelského rozhraní.

Podívejte se na vzorový fond vláken pro kompletní ukázku kódu, která demonstruje pracovní položky, položky časovače a periodické pracovní položky. Ukázka kódu byla původně napsána pro Windows 8.1, ale kód je možné znovu použít ve Windows 10.

Informace o opakujících se časovačích naleznete v tématu Vytvoření pravidelné pracovní položky.