TimerTimers

.NET fornisce due timer da usare in un ambiente con multithreading:.NET provides two timers to use in a multithreaded environment:

Nota

Alcune implementazioni .NET possono includere altri timer:Some .NET implementations may include additional timers:

  • System.Windows.Forms.Timer: un componente di Windows Form che genera un evento a intervalli regolari.System.Windows.Forms.Timer: a Windows Forms component that fires an event at regular intervals. Il componente non dispone di interfacce utente ed è progettato per l'uso in un ambiente a thread singolo.The component has no user interface and is designed for use in a single-threaded environment.
  • System.Web.UI.Timer: un componente ASP.NET che esegue postback asincroni o sincroni di pagina Web in base a intervalli regolari.System.Web.UI.Timer: an ASP.NET component that performs asynchronous or synchronous web page postbacks at a regular interval.
  • System.Windows.Threading.DispatcherTimer: un timer integrato nella coda del Dispatcher che viene elaborata in un intervallo di tempo specifico e con una priorità specifica.System.Windows.Threading.DispatcherTimer: a timer that is integrated into the Dispatcher queue which is processed at a specified interval of time and at a specified priority.

Classe System.Threading.TimerThe System.Threading.Timer class

La classe System.Threading.Timer consente di chiamare in modo continuativo un delegato a determinati intervalli di tempo.The System.Threading.Timer class enables you to continuously call a delegate at specified time intervals. È inoltre possibile usare questa classe per pianificare una singola chiamata a un delegato in un intervallo di tempo specifico.You also can use this class to schedule a single call to a delegate in a specified time interval. Il delegato viene eseguito su un thread ThreadPool.The delegate is executed on a ThreadPool thread.

Quando si crea un oggetto System.Threading.Timer, si specifica un delegato TimerCallback che definisce il metodo di callback, un oggetto di stato facoltativo passato al callback, il tempo di attesa prima della prima chiamata di callback e l'intervallo di tempo tra le chiamate di callback.When you create a System.Threading.Timer object, you specify a TimerCallback delegate that defines the callback method, an optional state object that is passed to the callback, the amount of time to delay before the first invocation of the callback, and the time interval between callback invocations. Per annullare un timer in sospeso, chiamare il metodo Timer.Dispose.To cancel a pending timer, call the Timer.Dispose method.

L'esempio seguente illustra come creare un timer che chiama il delegato fornito per la prima volta dopo un secondo (1000 millisecondi) e quindi ogni due secondi.The following example creates a timer that calls the provided delegate for the first time after one second (1000 milliseconds) and then calls it every two seconds. L'oggetto di stato nell'esempio viene usato per contare quante volte viene chiamato il delegato.The state object in the example is used to count how many times the delegate is called. Il timer viene arrestato dopo aver chiamato il delegato almeno 10 volte.The timer is stopped when the delegate has been called at least 10 times.

using namespace System;
using namespace System::Threading;

ref class TimerState
{
public:
    int counter;
};

ref class Example
{
private:
    static Timer^ timer;

public:
    static void TimerTask(Object^ state)
    {
        Console::WriteLine("{0:HH:mm:ss.fff}: starting a new callback.", DateTime::Now);

        TimerState^ timerState = dynamic_cast<TimerState^>(state);
        Interlocked::Increment(timerState->counter);
    }

    static void Main()
    {
        TimerCallback^ tcb = gcnew TimerCallback(&TimerTask);
        TimerState^ state = gcnew TimerState();
        state->counter = 0;
        timer = gcnew Timer(tcb, state, 1000, 2000);

        while (state->counter <= 10)
        {
            Thread::Sleep(1000);
        }

        timer->~Timer();
        Console::WriteLine("{0:HH:mm:ss.fff}: done.", DateTime::Now);
    }
};

int main()
{
    Example::Main();
}
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    private static Timer timer;

    static void Main(string[] args)
    {
        var timerState = new TimerState { Counter = 0 };

        timer = new Timer(
            callback: new TimerCallback(TimerTask),
            state: timerState,
            dueTime: 1000,
            period: 2000);

        while (timerState.Counter <= 10)
        {
            Task.Delay(1000).Wait();
        }

        timer.Dispose();
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: done.");
    }

    private static void TimerTask(object timerState)
    {
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: starting a new callback.");
        var state = timerState as TimerState;
        Interlocked.Increment(ref state.Counter);
    }

    class TimerState
    {
        public int Counter;
    }
}
Imports System.Threading

Module Program

    Private Timer As Timer

    Sub Main(args As String())

        Dim StateObj As New TimerState
        StateObj.Counter = 0

        Timer = New Timer(New TimerCallback(AddressOf TimerTask), StateObj, 1000, 2000)

        While StateObj.Counter <= 10
            Task.Delay(1000).Wait()
        End While

        Timer.Dispose()
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: done.")
    End Sub

    Private Sub TimerTask(ByVal StateObj As Object)

        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: starting a new callback.")

        Dim State As TimerState = CType(StateObj, TimerState)
        Interlocked.Increment(State.Counter)
    End Sub

    Private Class TimerState
        Public Counter As Integer
    End Class
End Module

Per altre informazioni ed esempi, vedere System.Threading.Timer.For more information and examples, see System.Threading.Timer.

Classe System.Timers.TimerThe System.Timers.Timer class

Un altro timer utilizzabile in un ambiente con multithreading è System.Timers.Timer, che per impostazione predefinita genera un evento in un thread ThreadPool.Another timer that can be used in a multithreaded environment is System.Timers.Timer that by default raises an event on a ThreadPool thread.

Quando si crea un oggetto System.Timers.Timer, è possibile specificare l'intervallo di tempo in cui si desidera generare un evento Elapsed.When you create a System.Timers.Timer object, you may specify the time interval in which to raise an Elapsed event. Usare la proprietà Enabled per indicare se un timer deve generare un evento Elapsed.Use the Enabled property to indicate if a timer should raise an Elapsed event. Se un evento Elapsed deve essere generato una sola volta dopo l'intervallo specificato, impostare AutoReset su false.If you need an Elapsed event to be raised only once after the specified interval has elapsed, set the AutoReset to false. Il valore predefinito della proprietà AutoReset è true, vale a dire che un evento Elapsed viene generato periodicamente in base all'intervallo definito dalla proprietà Interval.The default value of the AutoReset property is true, which means that an Elapsed event is raised regularly at the interval defined by the Interval property.

Per altre informazioni ed esempi, vedere System.Timers.Timer.For more information and examples, see System.Timers.Timer.

Vedere ancheSee also