Időszakos munkaelem létrehozása

Fontos API-k

Megtudhatja, hogyan hozhat létre rendszeresen ismétlődő munkaelemet.

Az időszakos munkaelem létrehozása

Rendszeres munkaelem létrehozásához használja a CreatePeriodicTimer metódust. Adjon meg egy lambdát, amely elvégzi a munkát, és az időszak paraméterrel adja meg a beküldések közötti időközt. Az időszak egy TimeSpan-struktúra használatával van megadva. A munkatétel minden alkalommal újra be lesz küldve, amikor az időszak letelik, ezért ügyeljen arra, hogy az időszak elég hosszú legyen ahhoz, hogy a munka befejeződhessen.

A CreatePeriodicTimer egy ThreadPoolTimer objektumot ad vissza. Tárolja ezt az objektumot abban az esetben, ha az időzítőt le kell mondani.

Note

Ne adjon meg nulla (vagy egy ezredmásodpercnél kisebb) értéket az intervallumhoz. Ez azt eredményezi, hogy a periodikus időzítő inkább egyszeri időzítőként viselkedik.

Note

A WinUI 3-alkalmazásokban a Microsoft.UI.Dispatching.DispatcherQueue elemben a DispatcherQueue.TryEnqueue használatával férhet hozzá a felhasználói felület szálához, és megjelenítheti a munkaelem előrehaladását. A részletekért tekintse meg a DispatcherQueue áttekintését.

Az alábbi példa létrehoz egy munkaelemet, amely 60 másodpercenként fut:

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

Az időszakos munkaelem törlésének kezelése (nem kötelező)

Szükség esetén a timerDestroyedHandlerrel kezelheti az időszakos időzítő lemondását. A CreatePeriodicTimer overload használatával megadhat egy további lambdát, amely az időszakos munkaelem megszakítását kezeli.

Az alábbi példa egy 60 másodpercenként ismétlődő időszakos munkaelemet hoz létre, és egy lemondáskezelőt is biztosít:

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.

                }));
        }));

Az időzítő megszakítása

Szükség esetén hívja meg a Cancel metódust, hogy leállítsa az időszakos munkaelem ismétlődését. Ha a munkaelem az időszakos időzítő megszakításakor fut, akkor a művelet befejeződhet. A TimerDestroyedHandler (ha meg van adva) akkor hívódik meg, amikor az időszakos munkaelem minden példányának végrehajtása befejeződött.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Remarks

Az egyszer használatos időzítőkkel kapcsolatos információkért lásd: Időzítő használata munkaelem elküldéséhez.

  • Last updated on