C# 异步并发操作，只保留最后一次操作

在我们业务操作时，难免会有多次操作，我们期望什么结果呢？

绝大部分情况，应该是只需要最后一次操作的结果，其它操作应该无效。

自定义等待的任务类

1. 可等待的任务类 AwaitableTask:

     /// <summary>
     /// 可等待的任务
     /// </summary>
     public class AwaitableTask
     {
         /// <summary>
         /// 获取任务是否为不可执行状态
         /// </summary>
         public bool NotExecutable { get; private set; }

         /// <summary>
         /// 设置任务不可执行
         /// </summary>
         public void SetNotExecutable()
         {
             NotExecutable = true;
         }

         /// <summary>
         /// 获取任务是否有效
         /// 注：对无效任务，可以不做处理。减少并发操作导致的干扰
         /// </summary>
         public bool IsInvalid { get; private set; } = true;

         /// <summary>
         /// 标记任务无效
         /// </summary>
         public void MarkTaskValid()
         {
             IsInvalid = false;
         }

         #region Task

         private readonly Task _task;
         /// <summary>
         /// 初始化可等待的任务。
         /// </summary>
         /// <param name="task"></param>
         public AwaitableTask(Task task) => _task = task;

         /// <summary>
         /// 获取任务是否已完成
         /// </summary>
         public bool IsCompleted => _task.IsCompleted;

         /// <summary>
         /// 任务的Id
         /// </summary>
         public int TaskId => _task.Id;

         /// <summary>
         /// 开始任务
         /// </summary>
         public void Start() => _task.Start();

         /// <summary>
         /// 同步执行开始任务
         /// </summary>
         public void RunSynchronously() => _task.RunSynchronously();

         #endregion

         #region TaskAwaiter

         /// <summary>
         /// 获取任务等待器
         /// </summary>
         /// <returns></returns>
         public TaskAwaiter GetAwaiter() => new TaskAwaiter(this);

         /// <summary>Provides an object that waits for the completion of an asynchronous task. </summary>
         [HostProtection(SecurityAction.LinkDemand, ExternalThreading = true, Synchronization = true)]
         public struct TaskAwaiter : INotifyCompletion
         {
             private readonly AwaitableTask _task;

             /// <summary>
             /// 任务等待器
             /// </summary>
             /// <param name="awaitableTask"></param>
             public TaskAwaiter(AwaitableTask awaitableTask) => _task = awaitableTask;

             /// <summary>
             /// 任务是否完成.
             /// </summary>
             public bool IsCompleted => _task._task.IsCompleted;

             /// <inheritdoc />
             public void OnCompleted(Action continuation)
             {
                 var This = this;
                 _task._task.ContinueWith(t =>
                 {
                     if (!This._task.NotExecutable) continuation?.Invoke();
                 });
             }
             /// <summary>
             /// 获取任务结果
             /// </summary>
             public void GetResult() => _task._task.Wait();
         }

         #endregion

     }

无效的操作可以分为以下俩种：

• 已经进行中的操作，后续结果应标记为无效
• 还没开始的操作，后续不执行

自定义任务类型 AwaitableTask中，添加俩个字段NotExecutable、IsInvalid：

     /// <summary>
     /// 获取任务是否为不可执行状态
     /// </summary>
     public bool NotExecutable { get; private set; }
     /// <summary>
     /// 获取任务是否有效
     /// 注：对无效任务，可以不做处理。减少并发操作导致的干扰
     /// </summary>
     public bool IsInvalid { get; private set; } = true;

2. 有返回结果的可等待任务类 AwaitableTask<TResult>：

     /// <summary>
     /// 可等待的任务
     /// </summary>
     /// <typeparam name="TResult"></typeparam>
     public class AwaitableTask<TResult> : AwaitableTask
     {
         private readonly Task<TResult> _task;
         /// <summary>
         /// 初始化可等待的任务
         /// </summary>
         /// <param name="task">需要执行的任务</param>
         public AwaitableTask(Task<TResult> task) : base(task) => _task = task;

         #region TaskAwaiter

         /// <summary>
         /// 获取任务等待器
         /// </summary>
         /// <returns></returns>
         public new TaskAwaiter GetAwaiter() => new TaskAwaiter(this);

         /// <summary>
         /// 任务等待器
         /// </summary>
         [HostProtection(SecurityAction.LinkDemand, ExternalThreading = true, Synchronization = true)]
         public new struct TaskAwaiter : INotifyCompletion
         {
             private readonly AwaitableTask<TResult> _task;

             /// <summary>
             /// 初始化任务等待器
             /// </summary>
             /// <param name="awaitableTask"></param>
             public TaskAwaiter(AwaitableTask<TResult> awaitableTask) => _task = awaitableTask;

             /// <summary>
             /// 任务是否已完成。
             /// </summary>
             public bool IsCompleted => _task._task.IsCompleted;

             /// <inheritdoc />
             public void OnCompleted(Action continuation)
             {
                 var This = this;
                 _task._task.ContinueWith(t =>
                 {
                     if (!This._task.NotExecutable) continuation?.Invoke();
                 });
             }

             /// <summary>
             /// 获取任务结果。
             /// </summary>
             /// <returns></returns>
             public TResult GetResult() => _task._task.Result;
         }

         #endregion
     }

添加任务等待器，同步等待结果返回：

    /// <summary>
     /// 获取任务等待器
     /// </summary>
     /// <returns></returns>
     public new TaskAwaiter GetAwaiter() => new TaskAwaiter(this);

     /// <summary>
     /// 任务等待器
     /// </summary>
     [HostProtection(SecurityAction.LinkDemand, ExternalThreading = true, Synchronization = true)]
     public new struct TaskAwaiter : INotifyCompletion
     {
         private readonly AwaitableTask<TResult> _task;

         /// <summary>
         /// 初始化任务等待器
         /// </summary>
         /// <param name="awaitableTask"></param>
         public TaskAwaiter(AwaitableTask<TResult> awaitableTask) => _task = awaitableTask;

         /// <summary>
         /// 任务是否已完成。
         /// </summary>
         public bool IsCompleted => _task._task.IsCompleted;

         /// <inheritdoc />
         public void OnCompleted(Action continuation)
         {
             var This = this;
             _task._task.ContinueWith(t =>
             {
                 if (!This._task.NotExecutable) continuation?.Invoke();
             });
         }

         /// <summary>
         /// 获取任务结果。
         /// </summary>
         /// <returns></returns>
         public TResult GetResult() => _task._task.Result;
     }

异步任务队列

     /// <summary>
     /// 异步任务队列
     /// </summary>
     public class AsyncTaskQueue : IDisposable
     {
         /// <summary>
         /// 异步任务队列
         /// </summary>
         public AsyncTaskQueue()
         {
             _autoResetEvent = new AutoResetEvent(false);
             _thread = new Thread(InternalRunning) { IsBackground = true };
             _thread.Start();
         }

         #region 执行

         /// <summary>
         /// 执行异步操作
         /// </summary>
         /// <typeparam name="T">返回结果类型</typeparam>
         /// <param name="func">异步操作</param>
         /// <returns>isInvalid:异步操作是否有效；result:异步操作结果</returns>
         public async Task<(bool isInvalid, T reslut)> ExecuteAsync<T>(Func<Task<T>> func)
         {
             var task = GetExecutableTask(func);
             var result = await await task;
             if (!task.IsInvalid)
             {
                 result = default(T);
             }
             return (task.IsInvalid, result);
         }

         /// <summary>
         /// 执行异步操作
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="func"></param>
         /// <returns></returns>
         public async Task<bool> ExecuteAsync<T>(Func<Task> func)
         {
             var task = GetExecutableTask(func);
             await await task;
             return task.IsInvalid;
         }

         #endregion

         #region 添加任务

         /// <summary>
         /// 获取待执行任务
         /// </summary>
         /// <param name="action"></param>
         /// <returns></returns>
         private AwaitableTask GetExecutableTask(Action action)
         {
             var awaitableTask = new AwaitableTask(new Task(action));
             AddPenddingTaskToQueue(awaitableTask);
             return awaitableTask;
         }

         /// <summary>
         /// 获取待执行任务
         /// </summary>
         /// <typeparam name="TResult"></typeparam>
         /// <param name="function"></param>
         /// <returns></returns>
         private AwaitableTask<TResult> GetExecutableTask<TResult>(Func<TResult> function)
         {
             var awaitableTask = new AwaitableTask<TResult>(new Task<TResult>(function));
             AddPenddingTaskToQueue(awaitableTask);
             return awaitableTask;
         }

         /// <summary>
         /// 添加待执行任务到队列
         /// </summary>
         /// <param name="task"></param>
         /// <returns></returns>
         private void AddPenddingTaskToQueue(AwaitableTask task)
         {
             //添加队列，加锁。
             lock (_queue)
             {
                 _queue.Enqueue(task);
                 //开始执行任务
                 _autoResetEvent.Set();
             }
         }

         #endregion

         #region 内部运行

         private void InternalRunning()
         {
             while (!_isDisposed)
             {
                 if (_queue.Count == )
                 {
                     //等待后续任务
                     _autoResetEvent.WaitOne();
                 }
                 while (TryGetNextTask(out var task))
                 {
                     //如已从队列中删除
                     if (task.NotExecutable) continue;

                     if (UseSingleThread)
                     {
                         task.RunSynchronously();
                     }
                     else
                     {
                         task.Start();
                     }
                 }
             }
         }
         /// <summary>
         /// 上一次异步操作
         /// </summary>
         private AwaitableTask _lastDoingTask;
         private bool TryGetNextTask(out AwaitableTask task)
         {
             task = null;
             while (_queue.Count > )
             {
                 //获取并从队列中移除任务
                 if (_queue.TryDequeue(out task) && (!AutoCancelPreviousTask || _queue.Count == ))
                 {
                     //设置进行中的异步操作无效
                     _lastDoingTask?.MarkTaskValid();
                     _lastDoingTask = task;
                     return true;
                 }
                 //并发操作，设置任务不可执行
                 task.SetNotExecutable();
             }
             return false;
         }

         #endregion

         #region dispose

         /// <inheritdoc />
         public void Dispose()
         {
             Dispose(true);
             GC.SuppressFinalize(this);
         }

         /// <summary>
         /// 析构任务队列
         /// </summary>
         ~AsyncTaskQueue() => Dispose(false);

         private void Dispose(bool disposing)
         {
             if (_isDisposed) return;
             if (disposing)
             {
                 _autoResetEvent.Dispose();
             }
             _thread = null;
             _autoResetEvent = null;
             _isDisposed = true;
         }

         #endregion

         #region 属性及字段

         /// <summary>
         /// 是否使用单线程完成任务.
         /// </summary>
         public bool UseSingleThread { get; set; } = true;

         /// <summary>
         /// 自动取消以前的任务。
         /// </summary>
         public bool AutoCancelPreviousTask { get; set; } = false;

         private bool _isDisposed;
         private readonly ConcurrentQueue<AwaitableTask> _queue = new ConcurrentQueue<AwaitableTask>();
         private Thread _thread;
         private AutoResetEvent _autoResetEvent;

         #endregion

添加异步任务队列类，用于任务的管理，如添加、执行、筛选等：

1. 自动取消之前的任务 AutoCancelPreviousTask

内部使用线程，循环获取当前任务列表，如果当前任务被标记NotExecutable不可执行，则跳过。

NotExecutable是何时标记的？

获取任务时，标记所有获取的任务为NotExecutable。直到任务列表中为空，那么只执行最后获取的一个任务。

2. 标记已经进行的任务无效 MarkTaskValid

当前进行的任务，无法中止，那么标记为无效即可。

     /// <summary>
     /// 上一次异步操作
     /// </summary>
     private AwaitableTask _lastDoingTask;
     private bool TryGetNextTask(out AwaitableTask task)
     {
         task = null;
         while (_queue.Count > )
         {
             //获取并从队列中移除任务
             if (_queue.TryDequeue(out task) && (!AutoCancelPreviousTask || _queue.Count == ))
             {
                 //设置进行中的异步操作无效
                 _lastDoingTask?.MarkTaskValid();
                 _lastDoingTask = task;
                 return true;
             }
             //并发操作，设置任务不可执行
             task.SetNotExecutable();
         }
         return false;
     }

后续执行完后，根据此标记，设置操作结果为空。

     /// <summary>
     /// 执行异步操作
     /// </summary>
     /// <typeparam name="T">返回结果类型</typeparam>
     /// <param name="func">异步操作</param>
     /// <returns>isInvalid:异步操作是否有效；result:异步操作结果</returns>
     public async Task<(bool isInvalid, T reslut)> ExecuteAsync<T>(Func<Task<T>> func)
     {
         var task = GetExecutableTask(func);
         var result = await await task;
         if (!task.IsInvalid)
         {
             result = default(T);
         }
         return (task.IsInvalid, result);
     }

实践测试

启动10个并发任务，测试实际的任务队列并发操作管理：

     public MainWindow()
     {
         InitializeComponent();
         _asyncTaskQueue = new AsyncTaskQueue
         {
             AutoCancelPreviousTask = true,
             UseSingleThread = true
         };
     }
     private AsyncTaskQueue _asyncTaskQueue;
     private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
     {
         // 快速启动9个任务
         for (var i = ; i < ; i++)
         {
             Test(_asyncTaskQueue, i);
         }
     }
     public static async void Test(AsyncTaskQueue taskQueue, int num)
     {
         var result = await taskQueue.ExecuteAsync(async () =>
         {
             Debug.WriteLine("输入:" + num);
             // 长时间耗时任务
             await Task.Delay(TimeSpan.FromSeconds());
             return num * ;
         });
         Debug.WriteLine($"{num}输出的:" + result);
     }

测试结果如下：

一共9次操作，只有最后一次操作结果，才是有效的。其它8次操作，一次是无效的，7次操作被取消不执行。