Erstellen ein regelmäßiges Arbeitselement

Wichtige APIs

Erfahren Sie, wie Sie eine Arbeitsaufgabe erstellen, die regelmäßig wiederholt wird.

Periodisches Arbeitselement erstellen

Verwenden Sie die CreatePeriodicTimer-Methode , um eine regelmäßige Arbeitsaufgabe zu erstellen. Geben Sie eine Lambda-Funktion an, die die Arbeit ausführt, und verwenden Sie den Periodenparameter , um das Intervall zwischen Übermittlungen anzugeben. Der Zeitraum wird mithilfe einer TimeSpan-Struktur angegeben. Die Arbeitsaufgabe wird jedes Mal erneut übermittelt, wenn der Zeitraum verstrichen ist. Stellen Sie daher sicher, dass der Zeitraum lang genug ist, um die Arbeit abzuschließen.

CreatePeriodicTimer gibt ein ThreadPoolTimer -Objekt zurück. Speichern Sie dieses Objekt, falls der Timer abgebrochen werden muss.

Hinweis

Vermeiden Sie die Angabe eines Nullwerts (oder eines Werts kleiner als eine Millisekunden) für das Intervall. Dies bewirkt, dass sich der periodische Timer stattdessen wie ein Single-Shot-Timer verhält.

Hinweis

Verwenden Sie in WinUI 3-Apps DispatcherQueue.TryEnqueue aus Microsoft.UI.Dispatching.DispatcherQueue, um auf den UI-Thread zuzugreifen und den Fortschritt aus dem Arbeitselement heraus anzuzeigen. Ausführliche Informationen finden Sie in der DispatcherQueue-Übersicht .

Im folgenden Beispiel wird eine Arbeitsaufgabe erstellt, die alle 60 Sekunden ausgeführt wird:

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

Abbrechen des wiederkehrenden Arbeitselements (optional)

Bei Bedarf können Sie das Abbrechen des periodischen Timers mit einem TimerDestroyedHandler verarbeiten. Verwenden Sie die CreatePeriodicTimer-Überladung , um eine zusätzliche Lambda-Funktion zu liefern, die den Abbruch der regelmäßigen Arbeitsaufgabe behandelt.

Im folgenden Beispiel wird eine regelmäßige Arbeitsaufgabe erstellt, die alle 60 Sekunden wiederholt wird und außerdem einen Abbruchhandler bereitstellt:

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.

                }));
        }));

Abbrechen des Timers

Rufen Sie bei Bedarf die Cancel-Methode auf, um zu verhindern, dass die regelmäßige Arbeitsaufgabe wiederholt wird. Wenn die Arbeitsaufgabe ausgeführt wird, wenn der periodische Timer abgebrochen wird, kann sie abgeschlossen werden. Der TimerDestroyedHandler (sofern angegeben) wird aufgerufen, wenn alle Instanzen der regelmäßigen Arbeitsaufgabe abgeschlossen sind.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Hinweise

Informationen zu Einweg-Timern finden Sie unter Verwenden eines Timers zum Übermitteln eines Arbeitselements.

  • Last updated on