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 periodeparameter om het interval tussen inzendingen op te geven. De periode wordt opgegeven met behulp van een tijdspannestructuur . 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.

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

Note

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

Note

Gebruik DispatcherQueue.TryEnqueueMicrosoft.UI.Dispatching.DispatcherQueue in WinUI 3-apps om toegang te krijgen tot de UI-thread en de voortgang van het werkitem weer te geven. Zie het overzicht van DispatcherQueue voor meer informatie.

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 periodieke timer annuleren met een TimerDestroyedHandler. Gebruik de overload CreatePeriodicTimer om een extra lambda te leveren 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 Annuleren aan om te voorkomen dat het periodieke werkitem wordt herhaald. Als het werkitem wordt uitgevoerd wanneer de periodieke timer wordt geannuleerd, mag het worden voltooid. TimerDestroyedHandler (indien opgegeven) wordt aangeroepen wanneer alle exemplaren van het periodieke werkitem zijn voltooid.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Remarks

Zie Een timer gebruiken om een werkitem in te dienen voor informatie over timers voor eenmalig gebruik.

  • Last updated on