Freigeben über

Timergesteuertes Übermitteln einer Arbeitsaufgabe

  • Artikel

Wichtige APIs

Hier erfahren Sie, wie Sie ein Arbeitselement erstellen, die nach dem Ablaufen eines Timers ausgeführt wird.

Erstellen eines einmaligen Zeitgebers

Verwenden Sie die CreateTimer-Methode, um einen Timer für die Arbeitsaufgabe zu erstellen. Geben Sie eine Lambda-Funktion an, die die Arbeit ausführt, und verwenden Sie den Verzögerungsparameter , um anzugeben, wie lange der Threadpool wartet, bevor die Arbeitsaufgabe einem verfügbaren Thread zugewiesen werden kann. 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 aus der Arbeitsaufgabe 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 bei Bedarf Abbruch und 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 Zeitgeber erstellt, der die Arbeitsaufgabe sendet, und ruft eine Methode auf, wenn die Arbeitsaufgabe abgeschlossen 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.
                    }

                }));
        }));

Abbrechen des Timers

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

DelayTimer.Cancel();

DelayTimer->Cancel();

Hinweise

Universelle Windows-Plattform -Apps (UWP) können nicht verwendet werden Thread.Sleep, da er den UI-Thread blockieren kann. Sie können stattdessen einen ThreadPoolTimer verwenden, um eine Arbeitsaufgabe zu erstellen. Dadurch wird die aufgabe verzögert, die von der Arbeitsaufgabe ausgeführt wird, ohne den UI-Thread zu blockieren.

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

Informationen zu wiederholten Zeitgebern finden Sie unter Erstellen einer regelmäßigen Arbeitsaufgabe.