Freigeben über

Verwenden Sie einen Timer, um eine Arbeitsaufgabe zu übermitteln.

Wichtige APIs

Erfahren Sie, wie Sie eine Arbeitsaufgabe erstellen, die ausgeführt wird, nachdem ein Timer abgelaufen ist.

Erstellen eines einmaligen Timers

Verwenden Sie die Methode CreateTimer, um einen Timer für das Arbeitselement zu erstellen. Stellen Sie eine Lambda-Funktion bereit, die die Arbeit ausführt, und verwenden Sie den Parameter Verzögerung, um anzugeben, wie lange der Threadpool wartet, bevor das Arbeitselement einem verfügbaren Thread zugewiesen wird. Die Verzögerung wird mithilfe einer TimeSpan--Struktur angegeben.

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 in drei Minuten ausgeführt wird:

TimeSpan delay = TimeSpan.FromMinutes(3);
            
ThreadPoolTimer DelayTimer = ThreadPoolTimer.CreateTimer(
    (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.
                //

            });

    }, delay);

TimeSpan delay;
delay.Duration = 3 * 60 * 10000000; // 10,000,000 ticks per second

ThreadPoolTimer ^ DelayTimer = ThreadPoolTimer::CreateTimer(
        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.
                    //

                    ExampleUIUpdateMethod("Timer completed.");

                }));

        }), delay);

Bereitstellen eines Abschlusshandlers

Behandeln Sie falls erforderlich den Abbruch und den Abschluss der Arbeitsaufgabe mit einem TimerDestroyedHandler. Verwenden Sie die CreateTimer--Überladung, um eine zusätzliche Lambda-Funktion zu liefern. Dies wird ausgeführt, wenn der Timer abgebrochen wird oder wenn die Arbeitsaufgabe abgeschlossen ist.

Im folgenden Beispiel wird ein Timer erstellt, der das Arbeitselement übermittelt und eine Methode aufruft, wenn das Arbeitselement fertiggestellt ist oder der Timer abgebrochen wird:

TimeSpan delay = TimeSpan.FromMinutes(3);
            
bool completed = false;

ThreadPoolTimer DelayTimer = ThreadPoolTimer.CreateTimer(
    (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.
                    //

                });

        completed = true;
    },
    delay,
    (source) =>
    {
        //
        // TODO: Handle work cancellation/completion.
        //


        //
        // Update the UI thread by using the UI core dispatcher.
        //
        Dispatcher.RunAsync(
            CoreDispatcherPriority.High,
            () =>
            {
                //
                // UI components can be accessed within this scope.
                //

                if (completed)
                {
                    // Timer completed.
                }
                else
                {
                    // Timer cancelled.
                }

            });
    });

TimeSpan delay;
delay.Duration = 3 * 60 * 10000000; // 10,000,000 ticks per second

completed = false;

ThreadPoolTimer ^ DelayTimer = ThreadPoolTimer::CreateTimer(
        ref new TimerElapsedHandler([&](ThreadPoolTimer ^ source)
        {
            //
            // TODO: Work
            //

            //
            // Update the UI thread by using the UI core dispatcher.
            //
            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([&]()
                {
                    //
                    // UI components can be accessed within this scope.
                    //

                }));

            completed = true;

        }),
        delay,
        ref new TimerDestroyedHandler([&](ThreadPoolTimer ^ source)
        {
            //
            // TODO: Handle work cancellation/completion.
            //

            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([&]()
                {
                    //
                    // Update the UI thread by using the UI core dispatcher.
                    //

                    if (completed)
                    {
                        // Timer completed.
                    }
                    else
                    {
                        // Timer cancelled.
                    }

                }));
        }));

Timer abbrechen

Wenn der Timer noch nach unten zählt, die Arbeitsaufgabe jedoch nicht mehr benötigt wird, rufen Sie Abbrechenauf. Der Timer wird abgebrochen, und die Arbeitsaufgabe wird nicht an den Threadpool übermittelt.

DelayTimer.Cancel();

DelayTimer->Cancel();

Bemerkungen

UWP-Apps (Universelle Windows-Plattform) können Thread.Sleep- nicht verwenden, da sie den UI-Thread blockieren kann. Sie können stattdessen einen ThreadPoolTimer verwenden, um ein Arbeitselement zu erstellen, und dies wird das von dem Arbeitselement ausgeführte Task verzögern, ohne dass der UI-Thread blockiert wird.

Im -Threadpoolbeispiel finden Sie ein vollständiges Codebeispiel, das Arbeitsaufgaben, Timer-Arbeitsaufgaben und regelmäßige Arbeitsaufgaben demonstriert. Das Codebeispiel wurde ursprünglich für Windows 8.1 geschrieben, der Code kann jedoch in Windows 10 wiederverwendet werden.

Informationen zu wiederkehrenden Timern finden Sie unter Erstellen eines regelmäßigen Arbeitselements.