C#: How to implement keep alive timers for many objects in a proper and efficient way?

Question

What I want to realize is easily explained, but because there are so many different possibilities I'm not really aware of the pro and cons for each possible approach:

In my application there are plenty (say some thousands of communication objects). When such object is idle for some while (meaning that certain methods are not called), it shall simply be closed (what this means in detail is not relevant here).

I'm thinking of a "timer", associated with each object, which is re-triggered every time I "use" the object. Like:

public void ReTrigger()
{
    lock (_some_locking)
    {
            //Reset the timer
            _timer.Stop();
            _timer.Start();
        }
    }
}

Note, my application is heavily using async/await and I would like to use a solution which fits best into this concept. I want to avoid a lot of additional threads just for running a lot of timers.

There are many different timers available:

System.Timers.Timer
System.Threading.Timer
System.Windows.Forms.Timer
System.Web.UI.Timer
System.Windows.Threading.DispatcherTimer

So, which one "fits" best into my concept of using asyncio ?

To put an alternative, would it be better to rely on a background task like

while (true)
{
     try
     {
        await Task.Delay(timeout, _cancellationToken)
        ... some action when expired ...
     }
     catch (TaskCanceledException)
     {
        // we have been re-triggered by "using" the object
     }
}
       

This fits better in my concept, however, in this case I need a new cancellation token after each re-trigger, which is not really nice.

What is the "golden way" way to solve my problem; preferably using async tasks?

Another solution would be a housekeeping task, which cyclically polls all active objects for being expired or not. This would work with just one running timer, but is also not very nice.

Answer 1

Here is a way to keep track of the expiration status of an object passively, without using timers. The last time that each object was used is stored in a private double field, and this field is updated every time the object is used. In case the object has not been used for a long time, the field will take the value double.MaxValue which means "expired", and will keep this value forever. The GetExpired method below handles the complexity of comparing and updating the field atomically and with thread-safety:

public static bool GetExpired(ref double lastUsed, TimeSpan slidingExpiration,
    bool touch)
{
    // Magic values, 0: Not initialized, double.MaxValue: Expired
    double previous = Volatile.Read(ref lastUsed);
    if (previous == double.MaxValue) return true;

    // Get current timestamp in seconds
    double now = (double)Stopwatch.GetTimestamp() / Stopwatch.Frequency;
    if (previous == 0D || now - previous < slidingExpiration.TotalSeconds)
    {
        // Not expired (unless preempted)
        if (!touch) return false;
        var original = Interlocked.CompareExchange(ref lastUsed, now, previous);
        return original == double.MaxValue;
        // In any other case that original != previous we've lost the race to update
        // the field, but its value should be very close to 'now'. So not expired.
    }
    else
    {
        // Expired (unless preempted)
        var original = Interlocked.CompareExchange(ref lastUsed, double.MaxValue,
            previous);
        return original == double.MaxValue || original == previous;
    }
}

Usage example:

public class MyComObject
{
    private readonly TimeSpan _slidingExpiration = TimeSpan.FromSeconds(60);
    private double _lastUsed;

    public MyComObject() // Constructor
    {
        GetExpired(ref _lastUsed, default, touch: true); // Start expiration "timer"
    }

    public bool IsExpired => GetExpired(ref _lastUsed, _slidingExpiration, touch: false);

    public bool TryDoSomething()
    {
        if (GetExpired(ref _lastUsed, _slidingExpiration, touch: true)) return false;
        //...
        return true; // The job was done
    }
}