Good approach to building a time based async service in C#

Question

I need to build a service that will run theoretically forever.

While running it will need to check a local cache once every couple of seconds, and if it finds new items in that cache it should create and execute a new Task for each new item.

My question is, what is a good approach to implementing such a service? My main concern is how should I do the time-based starting of async tasks.

I came up with two ways to do this

1. Use a System.Timers.Timer to push events and then run code when the event is fired

2. Create a method that will call itself using Task.Delay

Here are some examples of what I mean by those two methods:

Timer

public void Run()
{
    System.Timers.Timer timer = new System.Timers.Timer(TimeSpan.FromSeconds(2).TotalMilliseconds);
    CancellationTokenSource ts = new CancellationTokenSource();

    timer.Elapsed += async (sender, argz) => await CodeExecutor(ts.Token);
    timer.Start();
}

public async Task CodeExecutor(CancellationToken token)
{
    //Some logic
}

Task.Delay

private async Task RepeatableMethod(CancellationToken cancellationToken)
{
    try
    {
        //some logic
    }
    catch (Exception e)
    {
    }
    finally
    {
        await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken)
            .ContinueWith(_ => RepeatableMethod(cancellationToken),cancellationToken);
    }
}

I am not sure which method would better fit my scenario, and if there isn't a different way that would be even better than those two. My main concern is that I want the logic that I am executing every 2 seconds to be asynchronous and possibly parallel.

What would be considered a better approach in the following scenario, and is there another (good) way I can approach my case?

Answer 1

As far as I can see, it looks similar to a producer/consumer pattern.

You may use something like BlockingCollection for such scenario, but it's not async, it means a dedicated thread waiting for items will be required in this case. There is an async implementation by Stephen Cleary, which could provide similar functionality, in his AsyncEx library. More information about it could be found in his blog.

Or probably TPL Dataflow will be suitable, check this example.

Answer 2

A crude asynchronous timer in the form below is certainly possible:

async Task Timer(Timespan interval, Func<Task> someCallback, CancellationToken token)
{
     while (!token.IsCancellationRequested)
     {
        await Task.Delay(interval, token);
        await someAction(); // Or someAction?.Invoke();
     }
}

There are some things to watch for, however:

• In practice, using Task.Delay is not nearly as accurate as a System.Threading.Timer, since execution of the continuation needs to be scheduled - Under high load scenarios I've found that accuracies can often be worse than 15ms.
• The time taken to in the callback (someAction) needs to be considered. If this isn't trivial, then you may need to add a StopWatch around the callback and then subtract the time taken in the callback from the next Task.Delay if you want reasonably accurate callback frequency.
• You need to worry about re-entrancy. If the callback takes longer than the delay, then your timer will be throttled. In this case, you may need to remove await on the callback (if it is asynchronous), and at worst, if there is significant synchronous latency in the callback, then you may also need to launch the callback on it's own thread (e.g. Task.Run(() => Callback())) to ensure that the timer is re-entrant, possibly the risk of an unstable load on the callback.
• You might also need to consider adding a timeout to the callback, with a mechanism like this
• And of course the callback should be wrapped in an exception handler, and then decide on how to proceed when things go wrong. Retries are likely unnecessary, as the call will be made again on the next interval.

To me, I would typically stay with a System.Threading.Timer based solution - it is more accurate and is re-entrant, and a large number of timers can be created concurrently anyway, so there seems little going for a Task.Delay based timer.

Answer 3

Could using events solve your problems? You could emit an event whenever something is added to the cache, and execute the adequate operation in the event listener.