/// <summary>
        /// 使用简单工厂方法创建一个用于执行 <paramref name="asyncAction"/> 异步任务的重新进入状态机。
        /// </summary>
        /// <param name="asyncAction">要被异步重新进入状态机调用的具体异步任务。</param>
        /// <param name="reentrancyPolicy">重新进入策略。</param>
        public static ReentrancyStateMachine FromPolicy(Func <object, Task> asyncAction,
                                                        ReentrancyPolicy reentrancyPolicy)
        {
            ReentrancyStateMachine stateMachine;

            switch (reentrancyPolicy)
            {
            case ReentrancyPolicy.Disable:
                stateMachine = new DisableReentrancyStateMachine();
                break;

            case ReentrancyPolicy.RunImmediately:
                stateMachine = new RunImmediatelyReentrancyStateMachine();
                break;

            //case ReentrancyPolicy.CancelAndRestart:
            //    stateMachine = new CancelAndRestartReentrancyStateMachine();
            //    break;
            case ReentrancyPolicy.Queue:
                stateMachine = new QueueReentrancyStateMachine();
                break;

            case ReentrancyPolicy.KeepLast:
                stateMachine = new KeepLastReentrancyStateMachine();
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(reentrancyPolicy), reentrancyPolicy, null);
            }

            stateMachine.AsyncAction = asyncAction ?? throw new ArgumentNullException(nameof(asyncAction));
            return(stateMachine);
        }
Example #2
0
        /// <summary>
        /// 创建一个没有异步控制流的,带一个或多个泛型参数的异步命令。同时可以指定此异步的重新进入策略。
        /// </summary>
        /// <param name="asyncAction">异步任务。</param>
        /// <param name="reentrancyPolicy">异步任务的重新进入策略。</param>
        public AsyncCommand([NotNull] Func<T, Task> asyncAction,
            ReentrancyPolicy reentrancyPolicy = default)
            : base(reentrancyPolicy)
        {
            if (asyncAction == null)
                throw new ArgumentNullException(nameof(asyncAction));

            _asyncAction = (context, t) => asyncAction(t);
        }
Example #3
0
        /// <summary>
        /// 当派生类使用此构造函数构造父类时,指定异步任务的重新进入策略。
        /// 派生类需要自己处理异步任务本身,需要重写 <see cref="ExecuteAsyncCore"/> 方法来执行异步任务。
        /// </summary>
        /// <param name="reentrancyPolicy">异步任务的重新进入策略。</param>
        protected AsyncCommandBase(ReentrancyPolicy reentrancyPolicy = default)
        {
            if (!Enum.IsDefined(typeof(ReentrancyPolicy), reentrancyPolicy))
            {
                throw new InvalidEnumArgumentException(
                          nameof(reentrancyPolicy), (int)reentrancyPolicy, typeof(ReentrancyPolicy));
            }

            _reentrancyInvoker = ReentrancyStateMachine.FromPolicy(ExecuteWithStatesAsync, reentrancyPolicy);
            ReentrancyPolicy   = reentrancyPolicy;
        }
Example #4
0
 /// <summary>
 /// 创建用于执行指定异步任务 <paramref name="asyncAction"/> 的 <see cref="AsyncCommand"/>。
 /// 可选的,可以指定异步任务的重新进入策略。
 /// </summary>
 /// <param name="asyncAction">异步命令中执行的异步任务。</param>
 /// <param name="reentrancyPolicy">异步任务的重新进入策略。</param>
 public AsyncCommand([NotNull] Func <AsyncExecutingContext, Task> asyncAction,
                     ReentrancyPolicy reentrancyPolicy = default)
     : base(reentrancyPolicy)
 {
     _asyncAction = asyncAction ?? throw new ArgumentNullException(nameof(asyncAction));
 }