Freigeben über

Regelmäßige Aufgabe erstellen

Wichtige APIs

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

Erstelle das wiederkehrende Arbeitselement

Verwenden Sie die CreatePeriodicTimer--Methode, um ein periodisches Arbeitselement zu erstellen. Geben Sie eine Lambda-Funktion an, die die Arbeit ausführt, und verwenden Sie den Zeitraum Parameter, 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.

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 als Single-Shot-Timer verhält.

Hinweis Sie können CoreDispatcher.RunAsync verwenden, um auf die Benutzeroberfläche zuzugreifen und den Fortschritt des Arbeitselements 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);

Behandlung des Abbruchs der wiederkehrenden Aufgabe (optional)

Bei Bedarf können Sie die Stornierung des periodischen Timers mit einem TimerDestroyedHandlerbehandeln. Verwenden Sie die CreatePeriodicTimer- Überladung, um ein zusätzliches Lambda bereitzustellen, das den Abbruch des periodischen Arbeitsvorgangs behandelt.

Im folgenden Beispiel wird eine periodische Aufgabe erstellt, die alle 60 Sekunden wiederholt wird und außerdem einen Abbruch-Handler 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.

                }));
        }));

Timer abbrechen

Rufen Sie bei Bedarf die Cancel-Methode auf, um die wiederkehrende Arbeitsaufgabe zu beenden. Wenn eine Aufgabe ausgeführt wird, während der periodische Timer abgebrochen wird, darf sie abgeschlossen werden. Der TimerDestroyedHandler (sofern angegeben) wird aufgerufen, wenn alle Instanzen der periodischen Arbeitsaufgabe abgeschlossen sind.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Bemerkungen

Informationen zu Einweg-Zeitgebern finden Sie unter Verwendung eines Zeitgebers zur Abgabe einer Arbeitsaufgabe.

  • Last updated on