Noda Time and recurrent operations (c#)

Question

I'm trying to write a 'pinging' code that will post to some rest service once in a minute.

My simplest 'old' approach will be like:

while (true)
{
    if (cancellationToken.IsCancellationRequested)
    {
        return;
    }

    await Task.Delay(TimeSpan.FromMinutes(1), cancellationToken);

    try
    {
        await PingImpl(clientId, baseUri, cancellationToken);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "ping {BaseUri} {Endpoint} failed", baseUri, Endpoint);
    }
}

Now, to unit test the recurrent call to server, I would usually inject the delay duration to be a millisecond in production and a minute in production (I know that it will poll 'slower' than once in a minute because of the time it takes to perform a request, it is acceptable)

Now, with #codatime, I would like to not mess with injecting parameters and expect some extension on IClock like

   await _clock.Delay(...);

Then, the unit test code will advance the fake clock and trigger the operation.

Do you know about some elegant way to achieve such behavior?

Answer 1

IClock doesn't have any notion of delaying - it only answers the question of "what's the current time".

What you want is a different abstraction. In the GAX project I maintain as part of the Google Cloud client libraries, we have this abstraction:

public interface IScheduler
{
    Task Delay(TimeSpan delay, CancellationToken cancellationToken);
}

Just like IClock, there's then a singleton implementation which uses Task.Delay - and a test implementation which advances a clock. I would say that the test implementation has caused us a lot of problems over time, because it's a really complex thing to simulate. You can't just advance the clock and then return a completed task - because you'd want other asynchronous calls to occur in the "simulated time" between starting and completing the delay.

You may have simpler requirements of course - if you don't have anything else going on, you may just be able to advance the clock. But be aware of the limitations of that, in terms of other async operations not happening in the meantime.

The fundamental idea here is a really useful one - but it does get messy to implement.