Knowledge about C# Timers

In the multithreading column, knowledge related to C# timers has been written, but the content is not very complete. Recently, I have deepened some understanding, and I will make some notes.

https://threads.whuanle.cn/1.thread_basic/3.pool.html#%E8%AE%A1%E6%97%B6%E5%99%A8

Here, we do not discuss the timers in the desktop environment, but focus on the timers provided by .NET itself, which include:

System.Threading.Timer
System.Timers.Timer
PeriodicTimer

System.Threading.Timer is the basic timer in .NET upon which other timers are built.

The error of System.Threading.Timer is roughly in milliseconds.

There may be variations across different .NET versions, different operating systems, and different CPUs.

Its constructor is as follows:

// TimerCallback: function to be executed
// state: object passed
// dueTime: delay before execution, indicating when it should start
// period: how often to execute
Timer(TimerCallback callback, object? state, int dueTime, int period)

As shown in the following code, it immediately starts a timer that executes a function at one-second intervals:

void Main()
{ 
	using Timer timer = new Timer(WriteTime!, null, 0, 1000);
	Console.ReadLine();
}

void WriteTime(object data) =>
   Console.WriteLine(DateTime.Now.ToString("ss.fff"));

Or you can write it like this:

void Main()
{
	using Timer timer = new Timer(WriteTime);
	timer.Change(0, 1000);
	Console.ReadLine();
}

void WriteTime(object data) =>
   Console.WriteLine(DateTime.Now.ToString("ss.fff"));

It can be seen that

Because System.Threading.Timer implements IDisposable and IAsyncDisposable, remember to use using or manually call the Dispose function to release the timer, otherwise, it may lead to memory leaks.

Additionally, it is not necessary to have the constructor execute immediately; you can manually call the Change function to set it to start execution.

Equivalent writing:

void Main()
{
	using Timer timer = new Timer(WriteTime!);
	timer.Change(0, 1000);
	Console.ReadLine();
}

void WriteTime(object data) =>
   Console.WriteLine(DateTime.Now.ToString("ss.fff"));

If you do not want it to execute, you can set the delay time to -1, so that the timer will not execute at all.

using Timer timer = new Timer(WriteTime!, null, -1, 1000);

If you want it to execute at an appropriate time, you can first set the delay time to -1, and then until Change() is called to modify the timer's execution interval.

void Main()
{
	using Timer timer = new Timer(WriteTime!, null, -1, 1000);
	Console.WriteLine("Press Enter to start execution");
	Console.ReadLine();
	
	timer.Change(0, 1000);
	Console.ReadLine();
}

void WriteTime(object data) =>
   Console.WriteLine(DateTime.Now.ToString("ss.fff"));

If you want to dynamically modify the time interval of the next execution during execution, set the delay time but do not set the period.

For example, the following three examples will cause problems:

Timer timer;
void Main()
{
	timer = new Timer(WriteTime, null, -1, 1000);
	Console.ReadLine();
}

int time = 1000;
void WriteTime(object data)
{
	time = time + 1000;
	timer.Change(0, time);
	Console.WriteLine(DateTime.Now.ToString("ss.fff"));
}

Timer timer;
void Main()
{
	timer = new Timer(WriteTime, null, 0, 1000);
	timer.Change(0, 1000);

	Console.ReadLine();
}

int time = 1000;
void WriteTime(object data)
{
	time = time + 1000;
	timer.Change(0, time);
	Console.WriteLine(DateTime.Now.ToString("ss.fff"));
}

Timer timer;
void Main()
{
	timer = new Timer(WriteTime);
	timer.Change(0, 1000);

	Console.ReadLine();
}

int time = 1000;
void WriteTime(object data)
{
	time = time + 1000;
	timer.Change(0, time);
	Console.WriteLine(DateTime.Now.ToString("ss.fff"));
}

The correct approach is to ignore the period and set the delay time:

Timer timer;
void Main()
{
	timer = new Timer(WriteTime);
	timer.Change(0, 1000);

	Console.ReadLine();
}

int time = 1000;
void WriteTime(object data)
{
	Console.WriteLine(DateTime.Now.ToString("ss.fff"));
	timer.Change(time, 0);
}

For example, if each execution time is delayed by 1 second:

Timer timer;
void Main()
{
	timer = new Timer(WriteTime);
	timer.Change(0, -1);

	Console.ReadLine();
}

int time = 1000;
void WriteTime(object data)
{
	time = time + 1000;
	Console.WriteLine(DateTime.Now.ToString("ss.fff"));
	timer.Change(time, -1);
}

The time interval can be set to -1 or 0.

System.Timers.Timer is a wrapper around System.Threading.Timer, which makes it more convenient to use.

This is mainly reflected in:

• Interval replaces the Change() method;
• Elapsed binds an event that can bind multiple events, rather than binding through the constructor;
• AutoReset resets the timer;

System.Timers.Timer is easier to understand and use.

The following is an example where a function is executed once every second:

void Main()
{
	var timer = new System.Timers.Timer()
	{
		Interval = 1000
	};

	timer.Elapsed += WriteTime;

	timer.Start();
	Console.ReadLine();
	timer.Stop();
}

void WriteTime(object? sender, ElapsedEventArgs e)
{
	Console.WriteLine(DateTime.Now.ToString("ss.fff"));
}

The timer can be easily started and stopped, and events can be bound and unbound at any time.

It is important to note that since the timer is handled by a separate thread, if you do not use Dispose to manually release it or wrap it in using, the current timer will continue to run in the background and will not be collected by the garbage collector.

As shown in the following code, because the timer object is declared within the stack, after the garbage collection, the timer will also be reclaimed, and observing the effect will reveal that WriteTime is not executed.

void Main()
{
	var timer = new System.Threading.Timer(WriteTime, null, 0, 1000);
	GC.Collect();
	Console.ReadLine();
}

void WriteTime(object data) =>
   Console.WriteLine(DateTime.Now.ToString("ss.fff"));

However, using the following code, the garbage collector will not collect the timer, so it will still print continuously.

System.Threading.Timer timer;
void Main()
{
	timer = new System.Threading.Timer(WriteTime, null, 0, 1000);
	GC.Collect();
	Console.ReadLine();
}

void WriteTime(object data) =>
   Console.WriteLine(DateTime.Now.ToString("ss.fff"));

Similarly, the following code will lead to memory leaks:

void Main()
{
	Test test = new();
	GC.Collect();
	Console.ReadLine();
}

public class Test
{
	System.Threading.Timer timer;
	public Test()
	{
		timer = new System.Threading.Timer(WriteTime, null, 0, 1000);
	}

	void WriteTime(object data) =>
	   Console.WriteLine(DateTime.Now.ToString("ss.fff"));
}

Therefore, it is very necessary to avoid memory leaks.

void Main()
{
	using (Test test = new())
	{
		GC.Collect();
	}
	Console.ReadLine();
}

public class Test : System.IDisposable
{
	System.Threading.Timer timer;
	public Test()
	{
		timer = new System.Threading.Timer(WriteTime, null, 0, 1000);
	}

	void WriteTime(object data) =>
	   Console.WriteLine(DateTime.Now.ToString("ss.fff"));

	public void Dispose()
	{
		Console.WriteLine("Dispose");
		timer.Dispose();
	}

	~Test()
	{
		Console.WriteLine("~Test");
		timer.Dispose();
	}
}

PeriodicTimer is related to thread synchronization.

For example, after the timer triggers the function, since the function is executed in another thread, it is impossible to know when the function is completed. How can we ensure that the function is executed exactly once every second?

We can write it like this:

PeriodicTimer timer = new PeriodicTimer(TimeSpan.FromSeconds(1));

void Main()
{
	RepeatForEver();
	Console.ReadLine();
	timer.Dispose();
}

async void RepeatForEver()
{
	while (await timer.WaitForNextTickAsync())
		Console.WriteLine(DateTime.Now.ToString("ss.fff"));
}

Since async void is used, RepeatForEver is non-blocking and asynchronous. By using timer.WaitForNextTickAsync(), the timer can evaluate the execution time and ensure that each trigger time is exactly 1 second after the function completes.

As shown in the following code, although the waiting time is increased by 100ms, the timer will automatically compensate for the time difference, and it will not wait for 1 second to execute. Instead, it will execute approximately 900ms later, ensuring that the function is executed once every second, minus the execution time.

PeriodicTimer timer = new PeriodicTimer(TimeSpan.FromSeconds(1));

void Main()
{
	RepeatForEver();
	Console.ReadLine();
	timer.Dispose();
}

async void RepeatForEver()
{
	while (await timer.WaitForNextTickAsync())
	{
		Console.WriteLine(DateTime.Now.ToString("ss.fff"));
		await Task.Delay(100);
	}
}