Долгие асинхронные операции и очень быстрый пользователь

using System;
using System.ComponentModel;
using System.Runtime.CompilerServices;
 
using DALibrary.Interfaces;
 
using Services;
using Services.Interfaces;
 
namespace VModels
{
    public class BaseViewModel : IBaseViewModel
    {
        private readonly IBackgroundTaskQueue _taskQueue = ServiceLocator.Instance.GetService<IBackgroundTaskQueue>();
        private readonly IMainDA _mainDA = ServiceLocator.Instance.GetService<IMainDA>();
        private readonly Lazy<IWindowService> _windowService
            = new Lazy<IWindowService>(() => ServiceLocator.Instance.GetService<IWindowService>());
 
        protected IBackgroundTaskQueue TaskQueue => _taskQueue;
        protected IMainDA MainDA => _mainDA;
        protected IWindowService WindowService => _windowService.Value;
 
        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = "")
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

using System;
using System.Collections.Generic;
 
namespace Services
{
    public class ServiceLocator
    {
        private static ServiceLocator _instance;
        private readonly Dictionary<Type, object> _services = new Dictionary<Type, object>();
        private ServiceLocator() { }
 
        public static ServiceLocator Instance => _instance ?? (_instance = new ServiceLocator());
        public ServiceLocator Register<T>(T service)
        {
            _services[typeof(T)] = service;
            return this;
        }
        public T GetService<T>() => (T)_services[typeof(T)];
    }
}

sealed class HandlerInfo
{
    public Func<Task> Handler { get; }
    public bool SkipSame { get; }
 
    public HandlerInfo(Func<Task> handler, bool skipSame)
    {
        Handler = handler;
        SkipSame = skipSame;
    }
}

public abstract class ViewModelBase : ReactiveUI.ReactiveObject 
{
    private readonly Queue<HandlerInfo> _handlersQueue = new Queue<HandlerInfo>();
    private Thread _handlersThread = null;
 
    //Добавление обработчика в очередь и запуск потока, если ещё не запущен.
    protected void EnqueueTask(Func<Task> handler, bool skipSame = true)
    {
        lock (_handlersQueue)
        {
            _handlersQueue.Enqueue(new HandlerInfo(handler, skipSame));
 
            if (_handlersThread == null)
            {
                _handlersThread = new Thread(HandersThreadProc);
                _handlersThread.Start();
            }
        }
    }
 
    //Обработка очереди до её опустошения.
    private void HandersThreadProc()
    {
        while (true)
        {
            //Выбор следующего обработчика и пропуск лишних.
            var nextHandlerInfo = default(HandlerInfo);
            lock (_handlersQueue)
            {
                if (_handlersQueue.Count == 0)
                {
                    _handlersThread = null;
                    break;
                }
 
                nextHandlerInfo = _handlersQueue.Dequeue();
 
                if (nextHandlerInfo.SkipSame)
                {
                    while (_handlersQueue.Count > 0 && _handlersQueue.Peek().Handler.Method == nextHandlerInfo.Handler.Method)
                    {
                        _handlersQueue.Dequeue();
                    }
                }
            }
 
            //Выполнение.
            nextHandlerInfo.Handler().Wait();
        }
    }
}

//Примеры использования.
public sealed class SomeViewModel : ViewModelBase
{
    private async Task TestTask()
    {
        Debug.WriteLine("TestTask start");
        await Task.Delay(4000);
        Debug.WriteLine("TestTask end");
    }
 
    //V1
    protected override void InitObserve()
    {
        this.WhenAnyValue(vm => vm.DocumentType, vm => vm.StartDate)
            .Throttle(TimeSpan.FromMilliseconds(100))
            .ObserveOn(RxApp.MainThreadScheduler)
            .Subscribe(_ => EnqueueTask(TestTask));
    }
 
    //V2
    private void SomeUiEventHandler()
    {
        EnqueueTask(TestTask);
    }
 
    //V3
    public async Task DoOther()
    {
        //....
        await TestTask();
        //...
    }
}

namespace System.Threading.Tasks
{
    /// <summary>Класс выполняющий только одну последнюю задачу.</summary>
    public class OneRunningTask
    {
        private Task task; // Задача с исполняемым методом или методом, который нужно выполнить.
        private readonly object locker = new();
 
        /// <summary>Постановка метода в очередь на исполнение.</summary>
        /// <param name="action">Делегат метода.</param>
        /// <returns><see langword="true"/>, если не было другого исполняемого метода
        /// и этот метод начал сразу исполняться.<br/>
        /// <see langword="false"/> - какой-то метод исполняется и метод из
        /// <paramref name="action"/> ставится в очередь на исполнение.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="action"/> == null.</exception>
        /// <remarks>Если до окончания исполнения предыдущего метода, метод <see cref="Push(Action)"/>
        /// будет вызван ещё раз, то он заменит метод из очереди и тот не будет исполняться.</remarks>
        public bool Push(Action action)
        {
            if (action == null)
                throw new ArgumentNullException(nameof(action));
 
            Task newTask = new(action);
            newTask.ContinueWith(ContinueWith);
 
            lock (locker)
            {
                bool isFirst = task == null;
                task = newTask;
                if (isFirst)
                {
                    task.Start();
                    return false;
                }
                else
                {
                    return true;
                }
            }
        }
 
        // Метод продолжения задачи.
        // Если в task находится не завершённая задача,
        // то она запускается на выполнение.
        private void ContinueWith(Task comletedTask)
        {
            lock (locker)
            {
                if (task == comletedTask)
                {
                    task = null;
                }
                else
                {
                    task.Start();
                }
            }
        }
    }
}

        private static void PrintNum(int num)
        {
            Console.WriteLine($"Begin run #{num}.");
            Thread.Sleep(2500);
            Console.WriteLine($"Finish run #{num}.");
        }
 
        static void Main(string[] args)
        {
            OneRunningTask oneRunning = new();
            for (int i = 0; i < 10; i++)
            {
                oneRunning.Push(() => PrintNum(i));
                Thread.Sleep(1000);
            }
            Thread.Sleep(5000);
            Console.ReadLine();

    public class SyncMethod
    {
        private int oldNumber = -1;
 
        public async Task WaitingAnotherMethodsAsync(int number, Func<Task> action, int milliseconds = 10000)
        {
            int timeout = 0;
            int еxpectedNumber = number - 1;
 
            while (oldNumber < еxpectedNumber && timeout < milliseconds)
            {
                timeout++;
                await Task.Delay(1);
            }
 
            if (oldNumber < еxpectedNumber)
            {
                throw new ArgumentException($"Error message: \"Message after the {oldNumber} was lost.\"");
            }
            else if (oldNumber > еxpectedNumber)
            {
                throw new ArgumentException($"Error message: \"Message after the {oldNumber} already finished.\"");
            }
            else
            {
                await action();
 
                oldNumber++;
                if (oldNumber != number)
                    throw new ArgumentException("Error message: \"Something wrong ;(((.");
            }
        }
    }