Använda en timer för att skicka ett arbetsobjekt

viktiga API:er

Lär dig hur du skapar ett arbetsobjekt som körs efter att en timer har förflutit.

Skapa en engångstimer

Använd metoden CreateTimer för att skapa en timer för arbetsobjektet. Ange en lambda som utför arbetet och använd parametern delay för att ange hur länge trådpoolen väntar innan den kan tilldela arbetsobjektet till en tillgänglig tråd. Fördröjningen anges med hjälp av en TimeSpan-struktur .

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 på tre minuter:

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

Ange en slutförandehanterare

Vid behov hanterar du annullering och slutförande av arbetsobjektet med en TimerDestroyedHandler. Använd CreateTimer-överlagringen för att tillhandahålla ytterligare en lambda. Detta körs när timern avbryts eller när arbetsobjektet har slutförts.

I följande exempel skapas en timer som skickar arbetsobjektet och anropar en metod när arbetsobjektet är klart eller timern avbryts:

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

                }));
        }));

Avbryt timern

Om timern fortfarande räknar ned, men arbetsobjektet inte längre behövs, anropa Avbryt. Timern avbryts och arbetsobjektet skickas inte till trådpoolen.

DelayTimer.Cancel();

DelayTimer->Cancel();

Remarks

Windows appar bör undvika Thread.Sleep eftersom den blockerar den anropande tråden, vilket kan göra att användargränssnittet inte svarar om det anropas på användargränssnittstråden. Du kan använda en ThreadPoolTimer för att skapa ett arbetsobjekt i stället, och detta fördröjer uppgiften som utförs av arbetsobjektet utan att blockera användargränssnittstråden.

Se exempel på trådpool för ett komplett kodexempel som visar arbetsobjekt, tidsinställda arbetsobjekt och periodiska arbetsobjekt. Kodexemplet skrevs ursprungligen för Windows 8.1 men koden kan återanvändas i Windows 10.

Information om upprepade timer finns i Skapa ett periodiskt arbetsobjekt.

  • Last updated on