Dela via

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 fördröjning 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.

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

Om det behövs, hantera annulleringen och slutförandet av arbetsobjektet med en TimerDestroyedHandler . Använd CreateTimer överlagring 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, anropar du Avbryt. Timern avbryts och arbetsobjektet skickas inte till trådpoolen.

DelayTimer.Cancel();

DelayTimer->Cancel();

Anmärkningar

UWP-appar (Universal Windows Platform) kan inte använda Thread.Sleep eftersom det kan blockera användargränssnittstråden. Du kan använda en ThreadPoolTimer- för att skapa ett arbetsobjekt i stället, vilket fördröjer uppgiften som utförs av arbetsobjektet utan att blockera användargränssnittstråden.

Se trådpoolsexemplen i för ett fullständigt 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 återkommande timer finns i Skapa ett periodiskt arbetsobjekt.