debounce2.cs

    public static class Utils
    {

        private static Func<T> Delay<T>(Func<Task, T> continuation, int ms, CancellationTokenSource? src = null)
            where T : Task
        {
            Interlocked.Exchange(ref src, new CancellationTokenSource())?.Cancel();
            return () => continuation(Task.Delay(ms, src!.Token));
        }
        public static Func<Task<T>> Debounce<T>(Func<T> method, int ms = 250)
            => Delay(t => t.ContinueWith(_ => method, TaskContinuationOptions.OnlyOnRanToCompletion), ms);
    }

Debouncer.cs

public static class Utils
{
    public static Func<Task<T>> Debounce<T>(Func<T> method, int ms = 250, CancellationTokenSource? src = null) => delegate
    {
        Interlocked.Exchange(ref src, new CancellationTokenSource())?.Cancel();
        return Task.Delay(ms, src!.Token).ContinueWith(_ => method(), TaskContinuationOptions.OnlyOnRanToCompletion);
    };
}

public static class Debounce
    {
        private static Func<T> Delay<T>(Func<Task, T> continuation, int ms)
            where T : Task
        {
            CancellationTokenSource? src = null;
            return () =>
            {
                Interlocked.Exchange(ref src, new CancellationTokenSource())?.Cancel();
                return continuation(Task.Delay(ms, src!.Token));
            };
        }
        public static Func<Task<T>> Method<T>(Func<T> method, int ms = 250)
            => Delay(t => t.ContinueWith(_ => method(), TaskContinuationOptions.OnlyOnRanToCompletion), ms);
        public static Func<Task> Method(Action method, int ms = 250)
            => Delay(t => t.ContinueWith(_ => method(), TaskContinuationOptions.OnlyOnRanToCompletion), ms);
    }

    public static class Debounce
    {
        public static Func<Task<T>> Method<T>(Func<T> method, int ms = 250)
        {
            CancellationTokenSource? src = null;
            return delegate
            {
                Interlocked.Exchange(ref src, new CancellationTokenSource())?.Cancel();
                return Task.Delay(ms, src!.Token).ContinueWith(_ => method(), TaskContinuationOptions.OnlyOnRanToCompletion);
            };
        }

        public static Func<Task> Method(Action method, int ms = 250)
        {
            CancellationTokenSource? src = null;
            return delegate
            {
                Interlocked.Exchange(ref src, new CancellationTokenSource())?.Cancel();
                return Task.Delay(ms, src!.Token).ContinueWith(_ => method(), TaskContinuationOptions.OnlyOnRanToCompletion);
            };
        }
    }

One last go of shit...

    public static class Debounce
    {
        public static Func<Task<T>> Method<T>(Func<T> method, int ms = 250) => Delay(method, ms);

        public static Func<Task> Method(Action method, int ms = 250) => Delay(()=> { method(); return string.Empty; }, ms);

        private static CancellationToken GetToken(ref CancellationTokenSource? src)
        {
            Interlocked.Exchange(ref src, new CancellationTokenSource())?.Cancel();
            return src!.Token;
        }

        private static Func<Task<T>> Delay<T>(Func<T> method, int ms, CancellationTokenSource? src = null)
        { 
            return () => Task.Delay(ms, GetToken(ref src)).ContinueWith(_ => method(), TaskContinuationOptions.OnlyOnRanToCompletion);
        }
    }