Delen via

Een periodiek werkitem maken

Belangrijke API's

Meer informatie over het maken van een werkitem dat periodiek wordt herhaald.

Het periodieke werkitem maken

Gebruik de methode CreatePeriodicTimer om een periodiek werkitem te maken. Geef een lambda op die het werk uitvoert en gebruik de periode parameter om het interval tussen verzendingen op te geven. De periode wordt opgegeven met behulp van een TimeSpan structuur. Het werkitem wordt telkens opnieuw verzonden wanneer de periode is verstreken, dus zorg ervoor dat de periode lang genoeg is om het werk te voltooien.

CreateTimer- retourneert een ThreadPoolTimer--object. Sla dit object op als de timer moet worden geannuleerd.

Opmerking Vermijd het opgeven van een waarde van nul (of een waarde van minder dan één milliseconde) voor het interval. Dit zorgt ervoor dat de periodieke timer zich gedraagt als een eenmalige timer in plaats daarvan.

Opmerking U kunt CoreDispatcher.RunAsync- gebruiken om toegang te krijgen tot de gebruikersinterface en de voortgang van het werkitem weer te geven.

In het volgende voorbeeld wordt een werkitem gemaakt dat elke 60 seconden wordt uitgevoerd:

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

Annulering van het periodieke werkitem afhandelen (optioneel)

Indien nodig kunt u de annulering van de periodieke timer afhandelen met een TimerDestroyedHandler. Gebruik de CreatePeriodicTimer overbelasting om een extra lambda op te geven die de annulering van het periodieke werkitem afhandelt.

In het volgende voorbeeld wordt een periodiek werkitem gemaakt dat elke 60 seconden wordt herhaald en die ook een annuleringshandler levert:

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.

                }));
        }));

De timer annuleren

Roep indien nodig de methode Cancel aan om te voorkomen dat het periodieke werkitem wordt herhaald. Als het werkitem bezig is met uitvoering wanneer de periodieke timer wordt geannuleerd, mag het de taak afmaken. De TimerDestroyedHandler (indien opgegeven) wordt aangeroepen wanneer alle exemplaren van het periodieke werkitem zijn voltooid.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Opmerkingen

Zie Een timer gebruiken om een werkitem te verzendenvoor meer informatie over timers voor eenmalig gebruik.

  • Last updated on