RateLimit for IProgress<T>

[fernandozago]

Hello guys!

Recently I was working on a winforms app and doing some work with background tasks and updating the UI.

After a bit of coding I started to notice that my form is slowing down due to a lot of data being updated via IProgress.

Then I noticed that every time I call IProgress.Report(T value) the default implementation (Progress) makes a call to the UI using the current context synchronization (Post).

So I created a wrapper around Progress in order to limit calls to the UI.

Is there any plan to improve the implementation of IProgress for this kind of rate limit ?

Simple Rate Limited Work Around

namespace System
{
    public interface IRateLimitedProgress<T>
    {

        bool Report(T value, bool force = false);

    }

    public sealed class RateLimitedProgress<T> : Progress<T>, IRateLimitedProgress<T>
    {
        private DateTime _lastReport = DateTime.UtcNow;
        private readonly TimeSpan? _rateLimit = null;

        public RateLimitedProgress() : base()
        {
        }

        public RateLimitedProgress(TimeSpan rateLimit) : base()
        {
            _rateLimit = rateLimit;
        }

        public RateLimitedProgress(int milliseconds) : base()
        {
            _rateLimit = TimeSpan.FromMilliseconds(milliseconds);
        }

        public RateLimitedProgress(Action<T> handler) : base(handler)
        {

        }

        public RateLimitedProgress(Action<T> handler, TimeSpan rateLimit) : base(handler)
        {
            _rateLimit = rateLimit;
        }

        protected override void OnReport(T value)
        {
            _lastReport = DateTime.UtcNow;
            base.OnReport(value);
        }

        public bool Report(T value, bool ignoreRateLimit = false)
        {
            if (ignoreRateLimit || CheckRateLimit())
            {
                OnReport(value);
                return true;
            }
            else
            {
                return false;
            }
        }

        private bool CheckRateLimit()
        {
            return !(
                _rateLimit is not null
                && _lastReport.Add(_rateLimit.Value) > DateTime.UtcNow
            );
        }
    }
}

[huoyaoyuan]

System.Reactive has such utility for IObservable<T>, but it needs adaption from IProgress<T>.