Freigeben über

Erstellen ein regelmäßiges Arbeitselement

  • Artikel

Wichtige APIs

Hier erfahren Sie, wie Sie ein Arbeitselement erstellen, die regelmäßig wiederholt wird.

Erstellen der regelmäßigen Arbeitsaufgabe

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.

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

Beachten Sie, dass Sie keinen Wert von Null (oder einen Wert kleiner als eine Millisekunden) für das Intervall angeben. Dies bewirkt, dass sich der periodische Timer stattdessen als Single-Shot-Timer verhält.

Hinweis: Sie können CoreDispatcher.RunAsync verwenden, um auf die Benutzeroberfläche zuzugreifen und den Fortschritt aus der Arbeitsaufgabe anzuzeigen.

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

Behandeln des Abbruchs der regelmäßigen Arbeitsaufgabe (optional)

Bei Bedarf können Sie den Abbruch des periodischen Timers mit einem TimerDestroyedHandler behandeln. 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 Einmaligen Zeitgebern finden Sie unter Verwenden eines Zeitgebers zum Übermitteln einer Arbeitsaufgabe.