Creare un elemento di lavoro periodico

API importanti

• CreatePeriodicTimer
• ThreadPoolTimer

Informazioni su come creare un elemento di lavoro che si ripete periodicamente.

Creare l'elemento di lavoro periodico

Utilizzare il metodo CreatePeriodicTimer per creare un elemento di lavoro periodico. Specificare un'espressione lambda che esegue il lavoro e usare il parametro period per specificare l'intervallo tra gli invii. Il periodo viene specificato utilizzando una struttura TimeSpan. L'elemento di lavoro verrà inviato di nuovo ogni volta che scade il periodo, quindi assicurarsi che il periodo sia sufficientemente lungo per il completamento del lavoro.

CreateTimer restituisce un oggetto ThreadPoolTimer. Archiviare questo oggetto nel caso in cui il timer debba essere annullato.

Nota Evitare di specificare un valore pari a zero (o qualsiasi valore minore di un millisecondo) per l'intervallo. In questo modo, il timer periodico si comporta come timer singolo.

Nota È possibile usare CoreDispatcher.RunAsync per accedere all'interfaccia utente e mostrare lo stato di avanzamento dall'elemento di lavoro.

Nell'esempio seguente viene creato un elemento di lavoro che viene eseguito una volta ogni 60 secondi:

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

Gestire l'annullamento dell'elemento di lavoro periodico (facoltativo)

Se necessario, è possibile gestire l'annullamento del timer periodico con TimerDestroyedHandler. Usare l'overload CreatePeriodicTimer per fornire un'espressione lambda aggiuntiva che gestisce l'annullamento dell'elemento di lavoro periodico.

L'esempio seguente crea un elemento di lavoro periodico che si ripete ogni 60 secondi e fornisce anche un gestore di annullamento:

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.

                }));
        }));

Annullare il timer

Quando necessario, chiamare il metodo Cancel per interrompere la ripetizione dell'elemento di lavoro periodico. Se l'elemento di lavoro è in esecuzione quando il timer periodico viene annullato, è consentito completarlo. TimerDestroyedHandler (se specificato) viene chiamato quando tutte le istanze dell'elemento di lavoro periodico sono state completate.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Osservazioni:

Per informazioni sui timer a uso singolo, vedere Usare un timer per inviare un elemento di lavoro.

Argomenti correlati

• Inviare un elemento di lavoro al pool di thread
• Procedure consigliate per l'uso del pool di thread
• Usare un timer per inviare un elemento di lavoro