Udostępnij za pośrednictwem

Przesyłanie elementu roboczego przy użyciu czasomierza

ważne interfejsy API

Dowiedz się, jak utworzyć element roboczy uruchamiany po upływie czasomierza.

Tworzenie czasomierza pojedynczego strzału

Użyj metody CreateTimer, aby utworzyć czasomierz dla elementu roboczego. Dostarcz lambdę, która wykonuje pracę, i użyj parametru opóźnienia , aby określić, jak długo pula wątków czeka, zanim będzie mogła przypisać element pracy do dostępnego wątku. Opóźnienie jest określane przy użyciu struktury TimeSpan.

Uwaga Możesz użyć CoreDispatcher.RunAsync, aby uzyskać dostęp do interfejsu użytkownika i wyświetlić postęp związany z elementem roboczym.

Poniższy przykład tworzy element roboczy uruchamiany w ciągu trzech minut:

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

Podaj obsługiwacz zakończenia

W razie potrzeby zarządzaj anulowaniem i zakończeniem elementu roboczego za pomocą TimerDestroyedHandler. Użyj przeciążenia CreateTimer, aby podać dodatkową wartość lambda. Jest to uruchamiane po anulowaniu czasomierza lub zakończeniu działania elementu roboczego.

Poniższy przykład tworzy czasomierz, który przesyła element roboczy i wywołuje metodę po zakończeniu elementu roboczego lub anulowaniu czasomierza:

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.
                    }

                }));
        }));

Anulowanie czasomierza

Jeśli czasomierz nadal odlicza, ale element roboczy nie jest już potrzebny, wywołaj Anuluj. Czasomierz zostanie anulowany i element roboczy nie zostanie przesłany do puli wątków.

DelayTimer.Cancel();

DelayTimer->Cancel();

Uwagi

Aplikacje platformy uniwersalnej systemu Windows (UWP) nie mogą używać Thread.Sleep, ponieważ może blokować wątek interfejsu użytkownika. Zamiast tego można użyć ThreadPoolTimer, aby utworzyć element roboczy, co spowoduje opóźnienie zadania wykonanego przez element roboczy bez blokowania wątku interfejsu użytkownika.

Zobacz przykładową pulę wątków , aby zapoznać się z kompletnym przykładem kodu, który demonstruje elementy robocze, elementy robocze czasomierza i okresowe elementy robocze. Przykładowy kod został pierwotnie napisany dla systemu Windows 8.1, ale kod można ponownie użyć w systemie Windows 10.

Aby uzyskać informacje o powtarzających się timerach, zobacz Tworzenie okresowego elementu roboczego.