Delen via

Een timer gebruiken om een werkitem in te dienen

Belangrijke API's

Meer informatie over het maken van een werkitem dat wordt uitgevoerd nadat een timer is verstreken.

Een timer met één opname maken

Gebruik de methode CreateTimer om een timer voor het werkitem te maken. Geef een lambda op die het werk uitvoert en gebruik de vertraging parameter om op te geven hoe lang de threadgroep wacht voordat het werkitem kan worden toegewezen aan een beschikbare thread. De vertraging wordt opgegeven met behulp van een TimeSpan structuur.

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 in drie minuten wordt uitgevoerd:

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

Geef een voltooiingshandler op

Indien nodig kunt u de annulering en voltooiing van het werkitem afhandelen met een TimerDestroyedHandler. Gebruik de CreateTimer overload-functie om een extra lambda op te geven. Dit wordt uitgevoerd wanneer de timer wordt geannuleerd of wanneer het werkitem is voltooid.

In het volgende voorbeeld wordt een timer gemaakt die het werkitem verzendt en een methode aanroept wanneer het werkitem is voltooid of de timer wordt geannuleerd:

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.
                    }

                }));
        }));

De timer annuleren

Als de timer nog steeds aftelt, maar het werkitem niet meer nodig is, belt u Annuleren. De timer wordt geannuleerd en het werkitem wordt niet verzonden naar de threadgroep.

DelayTimer.Cancel();

DelayTimer->Cancel();

Opmerkingen

UWP-apps (Universal Windows Platform) kunnen geen Thread.Sleep- gebruiken omdat deze de UI-thread kan blokkeren. U kunt een ThreadPoolTimer- gebruiken om in plaats daarvan een werkitem te maken. Hierdoor wordt de taak die door het werkitem wordt uitgevoerd, vertraagd zonder de UI-thread te blokkeren.

Zie het threadgroepvoorbeeld voor een volledig codevoorbeeld met werkitems, timerwerkitems en periodieke werkitems. Het codevoorbeeld is oorspronkelijk geschreven voor Windows 8.1, maar de code kan opnieuw worden gebruikt in Windows 10.

Zie Een periodiek werkitem makenvoor meer informatie over herhalende timers.