Tworzenie okresowego elementu roboczego

ważne interfejsy API

Dowiedz się, jak utworzyć element roboczy, który jest powtarzany okresowo.

Utwórz okresowy element roboczy

Użyj metody CreatePeriodicTimer , aby utworzyć okresowy element roboczy. Podaj wyrażenie lambda, które realizuje to zadanie, i użyj parametru period, aby określić odstęp czasu między kolejnymi zgłoszeniami. Okres jest określany przy użyciu struktury TimeSpan . Element roboczy będzie ponownie przesyłany za każdym razem, gdy upłynie okres, więc upewnij się, że okres jest wystarczająco długi, aby wykonać pracę.

Funkcja CreatePeriodicTimer zwraca obiekt ThreadPoolTimer . Zapisz ten obiekt w przypadku, gdy czasomierz musi zostać anulowany.

Note

Należy unikać określania wartości zero (lub dowolnej wartości mniejszej niż jeden milisekund) dla interwału. Powoduje to, że czasomierz okresowy zachowuje się zamiast tego jak czasomierz jednorazowy.

Note

W aplikacjach WinUI 3 użyj elementu DispatcherQueue.TryEnqueue z Microsoft.UI.Dispatching.DispatcherQueue, aby uzyskać dostęp do wątku interfejsu użytkownika i wyświetlać postęp elementu roboczego. Szczegółowe informacje zawiera omówienie składnika DispatcherQueue.

Poniższy przykład tworzy element roboczy, który jest uruchamiany co 60 sekund:

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

Obsługa anulowania okresowego elementu roboczego (opcjonalnie)

W razie potrzeby można obsłużyć anulowanie timera okresowego za pomocą procedury obsługi TimerDestroyedHandler. Użyj przeciążenia CreatePeriodicTimer, aby przekazać dodatkowe wyrażenie lambda obsługujące anulowanie zadania okresowego.

Poniższy przykład tworzy okresowe zadanie, które powtarza się co 60 sekund, a także udostępnia procedurę obsługi anulowania:

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.

                }));
        }));

Anulowanie czasomierza

W razie potrzeby wywołaj metodę Cancel , aby zatrzymać powtarzanie okresowego elementu roboczego. Jeśli element roboczy jest uruchomiony w momencie anulowania timera okresowego, może zostać ukończony. Moduł obsługi TimerDestroyedHandler (jeśli został podany) jest wywoływany po zakończeniu wszystkich instancji okresowego elementu pracy.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Remarks

Aby uzyskać informacje o czasomierzach z jednym użyciem, zobacz Przesyłanie elementu roboczego przy użyciu czasomierza.

  • Last updated on