Dela via

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 inlämningar. 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.

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

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

Obs Du kan använda CoreDispatcher.RunAsync för att komma åt användargränssnittet och visa förloppet från arbetsobjektet.

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 tillhandahålla en ytterligare lambda som hanterar annullering 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

Om det behövs anropar du metoden Avbryt för att hindra det periodiska arbetsobjektet från att upprepas. Om arbetsobjektet körs när den periodiska timern avbryts tillåts det att slutföras. TimerDestroyedHandler (om det tillhandahålls) anropas när alla instanser av det periodiska arbetsobjektet har slutförts.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Anmärkningar

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