Skapa ett periodiskt arbetsobjekt

viktiga API:er

Lär dig hur du skapar ett arbetsobjekt som upprepas regelbundet.

Skapa det periodiska arbetsobjektet

Använd metoden CreatePeriodicTimer för att skapa ett periodiskt arbetsobjekt. Ange en lambda som utför arbetet och använd parametern period för att ange intervallet mellan inskickade. Perioden anges med hjälp av en TimeSpan-struktur . Arbetsobjektet skickas på nytt varje gång perioden förflutit, så se till att perioden är tillräckligt lång för att arbetet ska kunna slutföras.

CreatePeriodicTimer returnerar ett ThreadPoolTimer-objekt . Lagra det här objektet om timern måste avbrytas.

Note

Undvik att ange ett värde på noll (eller ett värde som är mindre än en millisekunder) för intervallet. Detta gör att den periodiska timern fungerar som en engångstimer i stället.

Note

I WinUI 3-appar använder du DispatcherQueue.TryEnqueue från Microsoft.UI.Dispatching.DispatcherQueue för att komma åt användargränssnittstråden och visa förloppet från arbetsobjektet. Mer information finns i Översikt över DispatcherQueue .

I följande exempel skapas ett arbetsobjekt som körs en gång var 60:e 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);

Hantera annullering av det periodiska arbetsobjektet (valfritt)

Om det behövs kan du hantera annulleringen av den periodiska timern med en TimerDestroyedHandler. Använd överlagringen CreatePeriodicTimer för att ange en ytterligare lambda som hanterar avbrytning av det periodiska arbetsobjektet.

I följande exempel skapas ett periodiskt arbetsobjekt som upprepas var 60:e sekund och som även tillhandahåller en hanterare för annullering:

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.

                }));
        }));

Avbryt timern

Vid behov anropar du metoden Avbryt för att stoppa det periodiska arbetsobjektet från att upprepas. Om arbetsobjektet är i gång när den periodiska timern avbryts får det slutföras. TimerDestroyedHandler (om en sådan tillhandahålls) anropas när alla instanser av det periodiska arbetsobjektet har slutförts.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Remarks

Information om engångstimers finns i Använda en timer för att skicka ett arbetsobjekt.

  • Last updated on