using System;

using System.Threading;

using System.Threading.Tasks;

using System.Diagnostics;

​

public class Program

{

    public static async Task Main()

    {

        using UpdateablePeriodicTimer timer = new(TimeSpan.FromMilliseconds(1));

        for (int i = 1; i <= 6; i++)

        {

            timer.Period = TimeSpan.FromMilliseconds(i * 100);

            Print($"Before await #{i}, Period: {timer.Period.TotalMilliseconds:#,0} msec");

            Stopwatch stopwatch = Stopwatch.StartNew();

            bool result = await timer.WaitForNextTickAsync();

            Print($"After await #{i}, duration: {stopwatch.ElapsedMilliseconds:#,0} msec, result: {result}");

        }

        Print($"Finished");

    }

​

    public class UpdateablePeriodicTimer : IDisposable

    {

         private readonly object _locker = new();

         private PeriodicTimer _timer; // Becomes null when disposed

         private PeriodicTimer _newTimer;

         private TimeSpan _period;

         private bool _waiting;

​

         public UpdateablePeriodicTimer(TimeSpan period)

         {

             _timer = new(period);

             _period = period;

         }

​

         public TimeSpan Period

         {

             get { lock (_locker) return _period; }

             set

             {

                 PeriodicTimer timerToDispose;

                 lock (_locker)

                 {

                     if (_timer is null) throw new ObjectDisposedException(null,

                         $"The {nameof(UpdateablePeriodicTimer)} has been disposed.");

                     if (_waiting)

                     {

                         timerToDispose = _newTimer;

                         _newTimer = new(value);

                     }

                     else

                     {

                         timerToDispose = _timer;

                         _timer = new(value);

                     }

                     _period = value;

                 }

                 timerToDispose?.Dispose();

             }

         }

​

         public async ValueTask<bool> WaitForNextTickAsync(

             CancellationToken cancellationToken = default)

         {

             cancellationToken.ThrowIfCancellationRequested();

             ValueTask<bool> waitTask;

             lock (_locker)

             {

                 if (_timer is null) return false; // Disposed

                 if (_waiting) throw new InvalidOperationException();

                 waitTask = _timer.WaitForNextTickAsync(cancellationToken);

                 _waiting = true;

             }

             try { return await waitTask.ConfigureAwait(false); }

             finally

             {

                 PeriodicTimer timerToDispose = null;

                 lock (_locker)

                 {

                     _waiting = false;

                     if (_timer is not null && _newTimer is not null)

                     {

                         timerToDispose = _timer;

                         _timer = _newTimer;

                         _newTimer = null;

                     }

                 }

                 timerToDispose?.Dispose();

             }

         }

​

         public void Dispose()

         {

             PeriodicTimer timerToDispose;

             lock (_locker)

             {

                 if (_timer is null) return; // Disposed

                 timerToDispose = _timer;

                 _timer = null;

                 _newTimer?.Dispose();

             }

             timerToDispose.Dispose();

         }

    }

​

    private static void Print(object value)

    {

        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} [{Thread.CurrentThread.ManagedThreadId}] > {value}");

    }

}

​