Erstellen ein regelmäßiges Arbeitselement

  • Artikel

Wichtige APIs

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

Erstellen das regelmäßige Arbeitselement

Verwenden Sie die CreatePeriodicTimer-Methode, um eine regelmäßige Arbeitsaufgabe zu erstellen. Stellen Sie eine Lambda-Funktion zum Ausführen der Arbeit bereit, und geben Sie mit dem period-Parameter das Intervall zwischen den Übermittlungen an. Das Intervall wird anhand einer TimeSpan-Struktur angegeben. Nach jedem Verstreichen des Intervalls wird das Arbeitselement erneut gesendet. Stellen Sie daher sicher, dass es lang genug ist, um die Arbeit auszuführen.

CreateTimer gibt ein ThreadPoolTimer-Objekt zurück. Speichern Sie das Objekt für den Fall, dass der Timer abgebrochen werden muss.

Hinweis Vermeiden Sie es, für das Intervall einen Wert von 0 (oder einen wert kleiner als eine Millisekunde) anzugeben. Andernfalls verhält sich der regelmäßige Timer wie ein einmaliger Timer.

Hinweis Sie können CoreDispatcher.RunAsync verwenden, um auf die Benutzeroberfläche zuzugreifen und den Fortschritt des Arbeitselements anzuzeigen.

Das folgende Beispiel erstellt ein Arbeitselement, 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 des regelmäßigen Arbeitselement (optional)

Bei Bedarf können Sie den Abbruch des regelmäßigen Timers mit einem TimerDestroyedHandler-Element verarbeiten. Stellen Sie mithilfe der CreatePeriodicTimer-Überladung eine zusätzliche Lambda-Funktion bereit, die den Abbruch der regelmäßigen Arbeitsaufgabe behandelt.

Das folgende Beispiel erstellt ein regelmäßiges Arbeitselement, die alle 60 Sekunden wiederholt wird, und stellt außerdem einen Abbruchhandler bereit:

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 Zeitgebers

Rufen Sie ggf. die Cancel-Methode auf, um die Wiederholung der regelmäßigen Arbeitsaufgabe zu beenden. Falls das Arbeitselement beim Abbruch des regelmäßigen Timers ausgeführt wird, kann sie noch abgeschlossen werden. Das TimerDestroyedHandler-Element (sofern verwendet) wird aufgerufen, wenn alle Instanzen der regelmäßigen Arbeitsaufgabe abgeschlossen wurden.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Hinweise

Informationen zu einmaligen Timern finden Sie unter Senden einer Arbeitsaufgabe mithilfe eines Timers.