/// <summary>
/// <para>Provides Debounce() and Throttle() methods.
/// Use these methods to ensure that events aren't handled too frequently.</para>
/// 
/// <para>Throttle() ensures that events are throttled by the interval specified.
/// Only the last event in the interval sequence of events fires.</para>
/// 
/// <para>Debounce() fires an event only after the specified interval has passed
/// in which no other pending event has fired. Only the last event in the
/// sequence is fired.</para>
/// </summary>
public class DebounceDispatcher
{
    private CancellationTokenSource debouncer;
    /// <summary>
    /// <para>Debounce an event by resetting the event timeout every time the event is 
    /// fired. The behavior is that the Action passed is fired only after events
    /// stop firing for the given timeout period.</para>
    /// 
    /// <para>Use Debounce when you want events to fire only after events stop firing
    /// after the given interval timeout period.</para>
    /// </summary>
    /// <param name="interval">Timeout in Milliseconds</param>
    /// <param name="action">Action<object> to fire when debounced event fires</object></param>
    /// <param name="param">optional parameter</param>
    public void Debounce(int interval, Action<object> action, object param = null)
    {
        if (debouncer != null && !debouncer.IsCancellationRequested)
        {
            debouncer.Cancel();
        }
        try
        {
            debouncer = new CancellationTokenSource();
            var t = Task.Delay(interval, debouncer.Token);
            t.ContinueWith((p) =>
            {
                if (p.Status == TaskStatus.RanToCompletion)
                    action.Invoke(param);
            });
            t.Start();
        }
        catch (Exception)
        {
            // duplicated invokes, the previous one was cancelled
            System.Console.WriteLine($"[{DateTime.Now}]: task was cancelled");
        }
    }
    private long throttler = 0;
    /// <summary>
    /// <para>This method throttles events by allowing only 1 event to fire for the given
    /// timeout period. Only the last event fired is handled - all others are ignored.
    /// Throttle will fire events every timeout ms even if additional events are pending.</para>
    /// 
    /// <para>Use Throttle where you need to ensure that events fire at given intervals.</para>
    /// </summary>
    /// <param name="interval">Timeout in Milliseconds</param>
    /// <param name="action">Action<object> to fire when debounced event fires</object></param>
    /// <param name="param">optional parameter</param>
    public void Throttle(int interval, Action<object> action, object param = null)
    {
        if (throttler == 0 || (DateTime.Now.Ticks - throttler) / 10000 >= interval)
        {
            action.Invoke(param);
            throttler = DateTime.Now.Ticks;
        }
    }
}