异步执行与进度显示的可扩展结构模型——设计模式的应用：策略模式和装饰者模式的结合

　　本文通过日常开发中遇到的"异步执行和进度显示"的场景探讨策略模式与装饰者模式的应用。也许很多人都会遇到过这么一个场景：需要执行一系列的耗时很长的操作，在这过程中还需要不断地向界面显示操作的进度，通常以进度条、或者进度条+进度消息等形式展现。具体场景例如：文件的传送、下载，大量内容的搜索，程序的安装过程等等。在些场景里有一些共性，就是都可以分成两个部分：业务操作的执行、操作进度的显示。而由于一些特定环境，这两部分操作还不能放在一起执行，必需分开按异步方式运行，也就是分别在不同的线程中执行。Winform桌面程序就是一个例子：窗体程序需要不断地刷新，如果任务执行和显示都同处于窗体线程中执行，就会导致程序出现挂死的状态（鼠标变成漏斗状，窗口拖动时在目录留下大量白色块，无法刷新和查看窗口内容），必需以后台线程执行任务操作，使窗体线程保持界面刷新。

　　至此，我们得出了基本的需求：异步执行两种类型的操作：业务操作执行、进度信息显示。这就是场景的共性之处，与共性相对的是特例，每个人开发时面对的“业务操作”都不进相同，“进度显示”的界面也各不相同，这也是接下来面向对象设计的出发点：通过将特例抽象为共同接口。于是我们可以定义两个类型：后台任务BackgroundTask、进度视图IProgressView ，如下图。

   

　　BackgroundTask 具有三个方法：RunAsync //异步执行任务； ReportProgress //显示进度；  Cancel  //取消执行。

　　IProgressView 具有三个方法：Started //已经启动； ProgressChanged  //进度已经变化；  Completed  //任务已经结束；

　　BackgroundTask 和 IProgressView 的方法都是上面场景中都会遇到的，因此上面的定义都很好的抽象了各自所代表的对象。任务需要将过程通知给视图，那对应的，BackgroundTask 应该持有 IProgressView 的实例。而不管具体的视图是什么样的，只要实现 IProgressView 接口提供给 BackgroundTask, 就能够获得进度通知。这样，很自然地就实现了一个经典模式：策略模式。

　　然而， IProgressView 接口对于实际需要的视图来说，还是过于抽象了，在具体的开发中还需要自定义不少的代码才能实现。为了提供进一步的便利，定义一个更具体化的视图的实现 FormProgressView，以简化以 Winform 窗体为视图的开发。如下图：

　　

　　上图的 FormProgressView 是一个以 C# 语言特性所绘的类图， TFORM 是一个泛型参数。FormProgressView 本身也实现了 IProgressView 接口，同时其内部通过 View 属性持有一个 IProgressView 的实例，这个实例的实际类似是由 TFORM 泛型参数指定，是从 System.Windows.Forms.Form 继承并实现 IProgressView 接口的窗体，FormProgressView 将所有的显示的调用转交给该窗体实例执行。FormProgressView 类通过截获了 Started 通知以实现在处理开始后创建并显示窗体，之后在将通知转交给窗体，并在窗体关闭后负责销毁窗体。这样，根据这一结构，开发者就可以完全关注于具体用于呈现进度的窗体外观的设计了，而无需关注如何获取通知，窗体实例化及销毁，以及异步执行时跨线程的 Winform 控件访问的封送调用问题。由于这些与窗体外观无关的内容对于任何具体视图实现而言都是相同的，不需要改变，于是它们都完全被封装在了 FormProgressView 和 BackgroundTask 中，真正实现“对扩展开放，对修改关闭”的开闭原则。而这又是一个经典模式：装饰者模式。

 　　至此，完成了一个基本的设计模型而已，以下将以 C# 代码实现上面的模型，对于其它语言的实现也是类似的。

• BackgroundTask 的实现

　　在上面没有提及关于 BackgroundTask 对于不同的具体任务操作的扩展性，而这也同样可以通过策略模式实现，但为了实现上的简便，直接使用 C# 语言里的委托来实现，即下图代码中的 TaskHandle 委托。

　　

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Windows.Forms;
using System.Threading;

namespace HHQ.Foundation.WinForm.Components
{
    /// <summary>
    /// 要异步执行的任务的委托；
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="args"></param>
    public delegate void TaskHandle(BackgroundTask sender, AsyncTaskArgs args);

    /// <summary>
    /// 后台任务；
    /// 任务是 TaskHandle 委托的实例，在一个独立的后台线程被执行；
    /// 如果 BackgroundTask 被用于 Winform 程序中，那么应该注意避免在任务中对在调用者线程中创建的 Winform 控件，因为 BackgroundTask 没有做任何跨线程调用控件的封送；
    /// 
    /// 不过可以放心的是，如果提供的 IProgressView 的实现中包含在调用者线程中创建的控件，则可以在 ProgressChanged 和 Completed 方法中放心调用这些控件；
    /// 因为 BackgroundTask 采用启动时调用者线程的 SynchronizationContext.Current 提供的同步对象进行封送调用；
    /// 如果当前缺少同步上下文（即 SynchronizationContext.Current == null），则通过线程池中执行的视图通知；
    /// </summary>
    public class BackgroundTask
    {
        /// <summary>
        /// 要异步执行的任务；
        /// 注意：TaskHandler 属性不是一个事件，一个 BackgroundTask 只能指定一个 TaskHandle 作为 TaskHandler，
        /// 指定新的值将覆盖以前设置的 TaskHandler ；
        /// </summary>
        public TaskHandle TaskHandler { get; set; }

        private IProgressView _progView = NullProgressView.View;
        /// <summary>
        /// 进度通知视图；
        /// </summary>
        public IProgressView ProgressView
        {
            get
            {
                return _progView;
            }
            set
            {
                if (value == null)
                {
                    _progView = NullProgressView.View;
                }
                else
                {
                    _progView = value;
                }
            }
        }

        // 标识是否是用户调用 TryCancel 或 Cancel 方法要结束任务的执行；； 
        private bool _cancellationPending;
        /// <summary>
        /// 标识是否是用户调用 TryCancel 或 Cancel 方法要结束任务的执行；； 
        /// 只读属性；
        /// </summary>
        public bool CancellationPending
        {
            get { return _cancellationPending; }
        }


        // 指示当前是否正在运行；； 
        private bool _isRunning;
        /// <summary>
        /// 指示当前是否正在运行；； 
        /// 只读属性；
        /// </summary>
        public bool IsRunning
        {
            get { return _isRunning; }
        }


        /// <summary>
        /// 内部的线程同步锁；
        /// </summary>
        private readonly object _syncLocker = new object();

        private SynchronizationContext _syncCtx;

        private Thread _thrd;

        /// <summary>
        /// 创建后台任务；
        /// </summary>
        public BackgroundTask()
        {
            _isRunning = false;
        }

        /// <summary>
        /// 创建后台任务；
        /// </summary>
        /// <param name="task">任务处理委托</param>
        /// <param name="progressView">进度通知视图</param>
        public BackgroundTask(TaskHandle task, IProgressView progressView)
        {
            _isRunning = false;
            TaskHandler = task;
            ProgressView = progressView;
        }

        /// <summary>
        /// 执行后台任务；
        /// 方法将等待后台线程完成后才返回；
        /// </summary>
        /// <param name="argument">任务参数</param>
        public void Run(object argument)
        {
            StartTask(argument, true, Timeout.Infinite);
        }

        /// <summary>
        /// 异步执行任务；
        /// 方法在启动线程之后将立即返回；
        /// </summary>
        /// <param name="argument">任务参数</param>
        public void RunAsync(object argument)
        {
            StartTask(argument, false, 0);
        }

        /// <summary>
        /// 开始执行任务；
        /// </summary>
        /// <param name="argument">任务参数</param>
        /// <param name="waitForCompleted">是否等待完成</param>
        /// <param name="waitTimeout">等待超时时长</param>
        private void StartTask(object argument, bool waitForCompleted, int waitTimeout)
        {
            lock (_syncLocker)
            {
                if (IsRunning)
                {
                    throw new InvalidOperationException("任务已经执行！");
                }
                _isRunning = true;
                _cancellationPending = false;
            }
            if (TaskHandler == null)
            {
                throw new InvalidOperationException("未指定要执行的任务！");
            }
            _syncCtx = SynchronizationContext.Current;
            _thrd = new Thread(DoTask);
            _thrd.IsBackground = true;
            _thrd.Start(argument);
            if (waitForCompleted)
            {
                _thrd.Join(waitTimeout);
            }
        }

        /// <summary>
        /// 任务执行线程的入口；
        /// </summary>
        /// <param name="arg"></param>
        private void DoTask(object arg)
        {
            AsyncTaskArgs args = new AsyncTaskArgs(arg);
            bool canceled = false ;
            Exception error = null;
            try
            {
                NotifyStarted(args);

                TaskHandler(this, args);

                canceled = args.Cancel;
            }
            catch (ThreadAbortException ex)
            {
                canceled = CancellationPending;
                error = ex;
                Thread.ResetAbort();
            }
            catch (Exception ex)
            {
                canceled = CancellationPending;
                error = ex;
            }
            finally
            {
                _isRunning = false;
                _thrd = null;
                NotifyCompleted(canceled, args.Result, error);
            }
        }

        /// <summary>
        /// 触发 ProgressView  的 Started 通知；
        /// </summary>
        /// <param name="args"></param>
        private void NotifyStarted(AsyncTaskArgs args)
        {
            BackgroundTask sender = this;
            if (_syncCtx != null)
            {
                _syncCtx.Post(delegate(object arg)
                {
                    ProgressView.Started(sender, args);
                },
                null);
            }
            else
            {
                ThreadPool.QueueUserWorkItem(delegate(object arg)
                {
                    ProgressView.Started(sender, args);
                },
                null);
            }
        }


        /// <summary>
        /// 触发 ProgressView  的 Completed 通知；
        /// </summary>
        /// <param name="canceled"></param>
        /// <param name="result"></param>
        /// <param name="error"></param>
        private void NotifyCompleted(bool canceled, object result, Exception error)
        {
            if (_syncCtx != null)
            {
                _syncCtx.Post(delegate(object arg)
                {
                    ProgressView.Completed(canceled, result, error);
                },
                null);
            }
            else
            {
                ThreadPool.QueueUserWorkItem(delegate(object arg)
                {
                    ProgressView.Completed(canceled, result, error);
                },
                null);
            }
        }

        /// <summary>
        /// 触发 ProgressView 的 ProgressChanged 的执行；
        /// </summary>
        /// <param name="percent"></param>
        public void ReportProgress(int percent)
        {
            ReportProgress(percent, null);
        }

        /// <summary>
        /// 触发 ProgressView 的 ProgressChanged 的执行；
        /// </summary>
        /// <param name="percent"></param>
        /// <param name="state"></param>
        public void ReportProgress(int percent, object state)
        {
            if (_syncCtx != null)
            {
                _syncCtx.Post(delegate(object perc)
                {
                    int p = (int)perc;
                    ProgressView.ProgressChanged(p, state);
                },
                percent);
            }
            else
            {
                ThreadPool.QueueUserWorkItem(delegate(object perc)
                {
                    int p = (int)perc;
                    ProgressView.ProgressChanged(p, state);
                },
                percent);
            }
        }

        /// <summary>
        /// 请求取消；
        /// 此方法不会终止后台线程，而是仅将 CancellationPending 置为 true，由后台执行的方法通过检查该属性自行退出；
        /// </summary>
        public void TryCancel()
        {
            lock (_syncLocker)
            {
                if (!IsRunning)
                {
                    throw new InvalidOperationException("当前任务未运行！");
                }
                _cancellationPending = true;
            }
        }

        /// <summary>
        /// 强制中断任务线程；
        /// 此方法将使 CancellationPending 置为 true 后，对任务线程执行 Abort 操作；
        /// 操作在任务线程上引起的 ThreadAbortedException 也将反映在 ProgressView 的 Completed 通知上；
        /// 此方法不等待任务线程的退出就立即返回；
        /// </summary>
        public void Cancel()
        {
            TryCancel();

            _thrd.Abort();
        }
    }
}

 

 

• FormProgressView 的实现

　　

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace HHQ.Foundation.WinForm.Components
{
    /// <summary>
    /// 进度通知视图，用于响应 BackgroundTask 的进度告或完成的信息；
    /// 
    /// 注意：视图定义的三个通知（Started, ProgressChanged, Completed）之间的是异步执行的，
    /// 能够保证的是 Started 通知肯定是第一个出现的， Completed 通知是最后出现的，ProgressChanged 通知在执行 BackgroundTask.ReportProgress 后出现，介于 Started、Completed 通知之间；
    /// </summary>
    public interface IProgressView
    {
        /// <summary>
        /// 任务开始执行；
        /// </summary>
        /// <param name="task"></param>
        /// <param name="args"></param>
        void Started(BackgroundTask task, AsyncTaskArgs args);

        /// <summary>
        /// 进度改变通知；
        /// </summary>
        /// <param name="percent"></param>
        /// <param name="data"></param>
        void ProgressChanged(int percent, object data);

        /// <summary>
        /// 进度完成通知；
        /// </summary>
        /// <param name="cancelled"></param>
        /// <param name="result"></param>
        /// <param name="error"></param>
        void Completed(bool cancelled, object result, Exception error);
    }
}

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;

namespace HHQ.Foundation.WinForm.Components
{
    /// <summary>
    /// FormProgressView 提供了 Winform 窗体实现的进度通知视图的适配器；
    /// 泛型参数 TFORM 必需是一个实现了 IProgressView 的 Winform 窗体的类型，并且定义一个不带参数的构造函数；
    /// 
    /// FormProgressView 维护指定类型的窗体的实例，默认情况下，在启动任务后自动以模态显示窗体；
    /// 在自动显示（AutoShowOnStart == true）并且以模态显示（IsModal==true）时，关闭窗体不会销毁之前的窗体实例；
    /// 除此种情形之外，窗体的关闭都会销毁实例，在下一次报告进度或者任务重新启动时，将会使用一个新的窗体实例；
    /// 
    /// 因此，开发者不应该依赖于窗体的特定实例而实现任务进度消息的显示；
    /// </summary>
    public class FormProgressView<TFORM> : IProgressView
        where TFORM : Form, IProgressView, new()
    {
        private readonly object _syncLocker = new object();
        
        private TFORM _view;
        /// <summary>
        /// 创建返回视图的实例；
        /// </summary>
        private TFORM View
        {
            get
            {
                if (_view == null)
                {
                    lock (_syncLocker)
                    {
                        if (_view == null)
                        {
                            TFORM form = new TFORM();
                            form.FormClosed += new FormClosedEventHandler(form_FormClosed);
                            _view = form;
                        }
                    }
                }
                return _view;
            }
        }

        /// <summary>
        /// 是否在获取 Started 通知后自动显示窗体；
        /// </summary>
        private bool _autoShowOnStart = true;
        /// <summary>
        /// 是否在获取 Started 通知后自动显示窗体；
        /// 在创建视图时通过构造函数指定，默认为 true；
        /// 只读属性；
        /// </summary>
        public bool AutoShowOnStart { get { return _autoShowOnStart; } }

        /// <summary>
        /// 窗体是否以模态显示；
        /// </summary>
        private bool _isModal = true;
        /// <summary>
        /// 窗体是否以模态显示；
        /// 在创建视图时通过构造函数指定，默认为 true；
        /// 只读属性；
        /// </summary>
        public bool IsModal { get { return _isModal; } }

        /// <summary>
        /// 创建窗体进度通知视图；
        /// </summary>
        public FormProgressView()
        {
        }

        /// <summary>
        /// 创建窗体进度通知视图；
        /// </summary>
        /// <param name="autoShowOnStart">是否自动在启动时自动显示窗体</param>
        /// <param name="isModal">是否以模式方式显示窗体</param>
        public FormProgressView(bool autoShowOnStart, bool isModal)
        {
            _autoShowOnStart = autoShowOnStart;
            _isModal = isModal;
        }

        /// <summary>
        /// 窗体关闭时清空对窗体的引用；
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void form_FormClosed(object sender, FormClosedEventArgs e)
        {
            if (_autoShowOnStart)
            {
                //如果窗体是以非模态方式（Show 方法）打开的，则关闭之后会销毁，此后不能继续使用该窗体，
                //因此需要清空对其的引用，并在需要时重建实例；
                //在以下两种情况下调用 Close 不会释放窗体：(1) 窗体是多文档界面 (MDI) 应用程序的一部分且是不可见的；(2) 您是使用 ShowDialog 显示的该窗体。
                if (!_isModal)
                {
                    _view = null;
                }
            }
            else
            {
                //由实现者自行显示窗体时，当窗体关闭后总是清空窗体的引用；
                _view = null;
            }
        }

        #region IProgressView 成员

        public void Started(BackgroundTask task, AsyncTaskArgs args)
        {
            this.View.Started(task, args);
            if (_autoShowOnStart)
            {
                if (_isModal)
                {
                    this.View.ShowDialog();
                }
                else
                {
                    this.View.Show();
                }
            }
        }

        public void ProgressChanged(int percent, object data)
        {
            this.View.ProgressChanged(percent, data);
        }

        public void Completed(bool cancelled, object result, Exception error)
        {
            this.View.Completed(cancelled, result, error);
        }

        #endregion
    }
}

 

 

 

 

• 异步执行与进度显示的可扩展结构模型的使用

            //创建后台任务实例；
            BackgroundTask task = new BackgroundTask();
            
            //指定任务进度显示的窗体视图；
            //泛型参数 TFORM 必需是一个实现了 IProgressView 的 Winform 窗体的类型，并且定义了一个不带参数的公开的构造函数；
            task.ProgressView = new FormProgressView<SimpleProgressDialog>();

            //指定任务的具体实现；指定 TaskHandle 委托的实例；
            task.TaskHandler = delegate(BackgroundTask sender, AsyncTaskArgs args)
            {
                //任务的实现；
                //在独立的后台线程被执行；不能包含访问其它线程创建的窗体、控件的代码；

                // Run 或 RunAsync 指定参数；
                //object param = args.Argument;

                //报告处理进度；
                //sender.ReportProgress(10);
                //sender.ReportProgress(20, "正在执行注册……");

                //保存完成结果；操作结果将反映到进度视图的 Completed 通知上；
                //不应使用抛出异常的方式结束处理，可以通过将 args.Cancel 置为 true 以通知视图任务是被取消的；
                
                //args.Cancel = false; //true-指示是否操作未完成而取消退出；
                //args.Result = data; //保存结果；
            };

            //以指定的参数实行任务；
            task.RunAsync(null);

 

　　总结一下，上述的结构设计的特点主要是将异步执行与进度显示这一通用场景中的固定逻辑抽象了出来，也就是多线程异步调用和异步通知的逻辑，同时也很好地支持了扩展，即对不同的视图，不同的任务实现的扩展。在这个例子中，通过分析识别场景中的共性与个性、不变与变化，便自然形成了一个面向对象的设计，在反观设计便发现这就是经典模式的应用。

　　附件中是上述的组件的可直接使用的版本。

 

　　附件：异步执行与进度显示的可扩展结构模型

 

　　注：《设计模式》该如何应用到实际开发中是我们学习面向对象设计时应该着重思考的，出于此目的，本人想通过《设计模式的应用》系列文章记录个人在日常开发中的心得体会，这篇文章就是开端。