Einreichen einer Arbeitsaufgabe mithilfe eines Timers

Wichtige APIs

Erfahren Sie, wie Sie eine Arbeitsaufgabe erstellen, die nach ablaufen eines Zeitgebers ausgeführt wird.

Erstellen Sie einen Einzelschuss-Timer

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

Verwenden Sie in WinUI 3-Apps DispatcherQueue.TryEnqueue aus Microsoft.UI.Dispatching.DispatcherQueue, um auf den UI-Thread zuzugreifen und den Fortschritt aus dem Arbeitselement anzuzeigen. Ausführliche Informationen finden Sie in der DispatcherQueue-Übersicht .

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

Einen Completion-Handler bereitstellen

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

Windows Apps sollten Thread.Sleep vermeiden, da sie den aufrufenden Thread blockiert, wodurch die Benutzeroberfläche nicht reagiert, wenn sie im UI-Thread aufgerufen wird. 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 Beispiel für den Threadpool finden Sie ein vollständiges Codebeispiel, das Arbeitselemente, Timerarbeitselemente und periodische Arbeitselemente veranschaulicht. 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 periodischen Arbeitselements.

  • Last updated on