深入WPF Dispatcher（补）

　　书接前文，前篇文章介绍了WPF中的Dispatcher，由于概念太多，可能不是那么好理解。这篇文章继续讨论，希望在线程和Dispatcher这个点上，能把它讲透。

从哪说起？

　　按照惯例，在深入问题之前，先找一个插入点，希望这个插入点能为朋友们所理解。

　　新建一个Window程序，代码如下：

int WINAPI _tWinMain(HINSTANCE hInstance,　 HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,　 int       nCmdShow)
{
    RegisterWindowClass(hInstance);　　　　                                      //1　

    HWND hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,        //2
        CW_USEDEFAULT, 0, CW_USEDEFAULT,z 0, NULL, NULL, hInstance, NULL);
    ShowWindow(hWnd, nCmdShow);

    MSG msg;                                                                     //3
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return (int) msg.wParam;
}

　　其中的RegisterWindowClass

WORD RegisterWindowClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;

    wcex.lpszClassName  = szWindowClass;

    wcex.lpfnWndProc    = WndProc;
    ...
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_PAINT:
    ...
}

　　这个创建窗口并显示的过程如下：

1. 调用RegisterWindowClass注册窗口类，关联其中的窗口过程WndProc。
2. 调用CreateWindow创建窗口并显示。
3. （主线程）进入GetMessage循环，取得消息后调用DispatchMessage分发消息。

　　这里的GetMessage循环就是所谓的消息泵，它像水泵一样源源不断的从线程的消息队列中取得消息，然后调用DispatchMessage把消息分发到各个窗口，交给窗口的WndProc去处理。

　　用一副图来表示这个过程：

1. 鼠标点击。
2. 操作系统底层获知这次点击动作，根据点击位置遍历找到对应的Hwnd，构建一个Window消息MSG，把这个消息加入到创建该Hwnd线程的消息队列中去。
3. 应用程序主线程处于GetMessage循环中，每次调用GetMessage获取一个消息，如果线程的消息队列为空，则线程会被挂起，直到线程消息队列存在消息线程会被重新激活。
4. 调用DispatchMessage分发消息MSG，MSG持有一个Hwnd的字段，指明了消息应该发往的Hwnd，操作系统在第2步构建MSG时会设置这个值。
5. 消息被发往Hwnd，操作系统回调该Hwnd对应的窗口过程WndProc，由WndProc来处理这个消息。

　　这是一个简略的Window消息处理流程，往具体说这个故事会很长，让我们把目光收回到WPF，看看WPF和即将介绍的Dispatcher在这个基础上都做了些什么，又有哪些出彩的地方。

仍然从Main函数说起

　　作为应用程序的入口点，我们仍然从Main函数走进WPF。

　　新建一个WPF工程，如下：

　　默认的WPF工程中中是找不到传统的Program.cs文件的，它的App.xaml文件的编译动作为ApplicationDefinition，编译后，编译器会自动生成App.g.cs文件，包含了Main函数。如下：

        [System.STAThreadAttribute()]
        [System.Diagnostics.DebuggerNonUserCodeAttribute()]
        public static void Main() 

　　　　{
            WpfApplication3.App app = new WpfApplication3.App();
            app.InitializeComponent();
            app.Run();
        }

　　这里出现了Application类，按MSDN上的解释，“Application 是一个类，其中封装了 WPF 应用程序特有的功能，包括：应用程序生存期；应用程序范围的窗口、属性和资源管理；命令行参数和退出代码处理；导航”等。

　　调用app.Run()之后，按照前面Win32的步骤，应用程序应进入到一个GetMessage的消息泵之中，那么对WPF程序来说，这个消息泵是什么样的呢？又和Dispatcher有什么关系呢？

走进Dispatcher

　　Dispatcher的构造函数是私有的，调用Dispacher.CurrentDispatcher会获得当前线程的Dispatcher，Dispatcher内部持有一个静态的所有Dispatcher的List。因为构造函数私有，只能调用CurrentDispatcher来获得Dispatcher，可以保证对同一个线程，只能创建一个Dispatcher。

　　Dispatcher提供了一个Run函数，来启动消息泵，内部的核心代码是我们所熟悉的，如：

        while (frame.Continue)
        {
            if (!GetMessage(ref msg, IntPtr.Zero, 0, 0))
                break;
            TranslateAndDispatchMessage(ref msg);
        }

　　这里出现了一个Frame的概念，暂且不谈，来看看Dispatcher相对于传统的消息循环，有哪些改进的地方。

Dispatcher的新意

　　在Winform的消息循环中，

1. 为了线程安全，调用Control的Invoke或者BeginInvoke方法可以在创建控件的线程上执行委托，方法的返回值分别为object和IAsyncResult。尽管可以使用IAsyncResult的IsCompleted和AsyncWaitHandle等方法来轮询或者等待委托的执行，但对于对任务的控制来讲，这个粒度是不够的，我们不能取消（Cancel）一个已经调用BeginInvoke的委托任务，也不能更换两个BeginInvoke的执行顺序。
2. 更为友好的接口支持，Windows编程中，在窗口消息循环中加入Hook是常见的需求，Dispatcher提供了DispatcherHooks类，以Event的形式对外提供了OperationAborted，OperationCompleted，OperationPosted等事件。

　　这里的Operation指的是DispatcherOperation，为了更好的控制消息循环，WPF引入了DispatcherOperation来封装Window消息，这个DispatcherOperation如下：

DispatcherOpration

public sealed class DispatcherOperation 
{ 
    public Dispatcher Dispatcher { get; } 
    public DispatcherPriority Priority { get; set; } 
    public object Result { get; } 
    public DispatcherOperationStatus Status { get; }
    public event EventHandler Aborted; 
    public event EventHandler Completed;
    public bool Abort(); 
    public DispatcherOperationStatus Wait(); 
    public DispatcherOperationStatus Wait(TimeSpan timeout); 
}

　　DispatcherOperation类看起来还是比较简单明了的，以属性的形式暴露了Result（结果），Status（状态），以及用事件来指出这个Operation何时结束或者取消。其中比较有意思的是Priority属性，从字面来看，它表示了DispatcherOperation的优先级，而且提供了get和set方法，也就是说，这个DispatcherOperation是可以在运行时更改优先级的。那么这个优先级是怎么回事，Dispatcher又是如何处理DispatcherOperation的呢，让我们深入DispatcherOperation，来看看它是如何被处理的。

深入DispatcherOperation（DO）

　　所谓深入，也要有的放矢，从三个方面来谈一下DispatcherOperation：

1. DispatcherOperation是如何被创建的。
2. DispatcherOperation是何时被执行的。
3. DispatcherOperation是怎样被执行的。

　　Dispatcher提供了BeginInvoke和Invoke两个方法，其中BeginInvoke的返回值是DispatcherOperation，Invoke函数的内部调用了BeginInvoke，也就是说，DispatcherOperation就是在这两个函数中被创建出来的。我们可以调用这两个函数创建新的DO，WPF内部也调用了这两个函数，把Window消息转化为DispatcherOperation，用一副图表示如下：

1. 窗口过程WndProc接收到Window消息，调用Dispatcher的Invoke方法，创建一个DispatcherOperation。Dispatcher内部持有一个DispatcherOperation的队列，用来存放所有创建出来的DispatcherOperation。默认一个DO被创建出来后，会加入到这个队列中去。WndProc调用Invoke的时候比较特殊，他传递的优先级DispatcherPriority为Send，这是一个特殊的优先级，在Invoke时传递Send优先级WPF会直接执行这个DO，而不把它加入到队列中去。
2. 用户也可以随时调用Invoke或者BeginInvoke方法加入新的DO，在DispatcherOperation处理的时候也可能会调用BeginInvoke加入新的DO。

　　DO被加入到Dispatcher的队列中去，那么这个队列又是何时被处理呢？Dispatcher在创建的时候，创建了一个隐藏的Window，在DO加入到队列后，Dispatcher会向自己的隐藏Window发送一个自定义的Window消息（DispatcherProcessQueue）。当收到这个消息后，会按照优先级和队列顺序取出第一个DO并执行：

1. 用户调用BeginInvoke。
2. Dispatcher创建了一个DO，加入到DO队列中去，并向自己的隐藏窗口Post自定义消息（DispatcherProcessQueue）。
3. 创建隐藏窗口时会Hook它的消息，当收到的消息为DispatcherProcessQueue时，按照优先级取出队列中的一个DO，并执行。

　　每加入一个DO就会申请处理DO队列，在DO的优先级（DispatcherPriority）被改变的时候也会处理DO队列，DO在创建时声明了自己的优先级，这个优先级会影响到队列的处理顺序。

DispatcherTimer

　　鉴于线程亲缘性，当需要创建Timer并访问UI对象时，多使用DispatcherTimer。DispatcherTimer的一个简单用法如下：

  var dispatcherTimer = new System.Windows.Threading.DispatcherTimer();   
  dispatcherTimer.Tick += new EventHandler(dispatcherTimer_Tick);
  dispatcherTimer.Interval = new TimeSpan(0,0,1);
  dispatcherTimer.Start(); 

　　在DispatcherTimer的内部，Timer的Tick事件处理也被包装成了DispatcherOperation，并调用BeginInvoke加入到Dispatcher中去。当这个DO被执行后，如果DispatcherTimer的状态仍然为Enable，DispatcherTimer会继续调用BeginInvoke加入新的DO。关于Timer的时间处理，Dispatcher会向自己的隐藏窗口调用SetTimer并计算时间间隔，当然，因为DispatcherOperation有优先级，不能保状正好在时间间隔时执行这个DO，这个执行的时间会比预计时间偏后而不会超前。

UI线程和Dispatcher

　　通常，WPF启动时具有两个线程，一个处理呈现（Render），另一个用于管理UI。关于Render线程，请参见前文。这个管理UI的线程通常被称为UI线程。在WPF中，所有UI对象的基类为DispatcherObject，WPF在对所有DispatcherObject属性操作前进行了线程亲缘性校验，只有在创建UI对象的线程中才可以访问该UI对象。

　　前面提到，由于Dispatcher构造函数私有，一个线程最多只能有一个Dispatcher。对UI线程来说，Dispatcher的主要作用就是对任务项（DispatcherOperation）进行排队。对UI对象来说，DispatcherObject有一个Dispatcher属性，可以获得创建该UI对象线程的Dispatcher。这种设计通过Dispatcher统一了UI对象的操作，从使用上隔离了UI对象和线程间的关系。

多线程

　　多线程操作简单分为两种：多工作线程和多UI线程，当然，也可以有多工作多UI线程，思路是一样的，省去不谈。

　　程序启动时默认的主线程就是UI线程，它在调用Application.Run（也就是Dispatcher.Run）之后进入了一个GetMessage的循环中，对Window消息进行响应并构建执行一个个的DispatcherOperation。默认对UI对象的操作都是在这个主线程中，如果进行耗时很长的操作就会造成UI线程长时间不能继续响应Window消息，造成界面假死等一些的UI响应问题。对这种耗时较长的操作一般需要工作线程来帮忙，操作结束后再通过Dispatcher把结果Invoke到UI线程，如：

TextBlock textBlock = new TextBlock() { Text = "1" }; 
Thread thread = new Thread(new ThreadStart(() => 
    { 
        //做一些耗时操作，这里用线程休眠10秒来模拟 
         Thread.Sleep(TimeSpan.FromSeconds(10));
        textBlock.Dispatcher.Invoke(new Action(() => 
            { 
                textBlock.Text = "2"; 
            })); 
    })); 
thread.Start();

　　当然，除了新建工作线程，也可以使用BackgroundWorker或者线程池中线程来进行耗时操作，操作结束后需要调用UI对象Dispatcher的Invoke或者BeginInvoke方法来操作UI，否则会抛出InvalidOperationException来提示不可跨线程访问UI对象。

　　这种多工作线程是很常见的，一般我们讨论的多线程大多指这种多工作线程单一UI线程，那么如何创建多UI线程的程序呢？

多UI线程

　　在谈多UI线程之前，先说说多UI线程使用的场景：

　　大多数情况下，我们是不需要多UI线程的，所谓多UI线程，就是指有两个或者两个以上的线程创建了UI对象。这种做法的好处是两个UI线程会分别进入各自的GetMessage循环，如果是需要多个监视实时数据的UI，或者说使用了DirectShow一些事件密集的程序，可以考虑新创建一个UI线程（GetMessage循环）来减轻单一消息泵的压力。当然，这样做的坏处也很多，不同UI线程中的UI对象互相访问是需要进行Invoke通信的，为了解决这个问题，WPF提供了VisualTarget来用于跨线程将一个对象树连接到另一个对象树，如：

    public class VisualHost : FrameworkElement
    {
        public Visual Child
        {
            get { return _child; }
            set
            {
                if (_child != null)
                    RemoveVisualChild(_child);
                _child = value;
                if (_child != null)
                    AddVisualChild(_child);
            }
        }
        protected override Visual GetVisualChild(int index)
        {
            if (_child != null && index == 0)
                return _child;
            else
                throw new ArgumentOutOfRangeException("index");
        }
        protected override int VisualChildrenCount
        {
            get { return _child != null ? 1 : 0; }
        }
        private Visual _child;
    }

　　在另一个UI线程下的VisualTarget：

    Window win = new Window();
    win.Loaded += (s, ex) =>
        {
            VisualHost vh = new VisualHost();
            HostVisual hostVisual = new HostVisual();
            vh.Child = hostVisual;
            win.Content = vh;
            Thread thread = new Thread(new ThreadStart(() =>
            {
                VisualTarget visualTarget = new VisualTarget(hostVisual);
                DrawingVisual dv = new DrawingVisual();
                using (var dc = dv.RenderOpen())
                {
                    dc.DrawText(new FormattedText("UI from another UI thread",
                        System.Globalization.CultureInfo.GetCultureInfo("en-us"),
                        FlowDirection.LeftToRight,
                        new Typeface("Verdana"),
                        32,
                        Brushes.Black), new Point(10, 0));
                }
                visualTarget.RootVisual = dv;
                Dispatcher.Run();  //启动Dispatcher
 
            }));
            thread.SetApartmentState(ApartmentState.STA);
            thread.IsBackground = true;
            thread.Start();
        };
    win.Show();
 

　　当然，这个多UI线程只是为了更好的捋清线程间的关系，实际使用中的例子并不是很常见。

总结

　　Dispatcher是WPF中很重要的一个概念，WPF所有UI对象都是运行在Dispatcher上的。Dispatcher的一些设计思路包括Invoke和BeginInvoke等从WinForm时代就是一直存在的，只是使用了Dispatcher来封装这些线程级的操作。剩余一些概念包括跨线程通信的Freezable以及详细的优先级顺序DispatcherPriority本文都没有细谈，以后的文章中会逐步介绍，希望大家多多支持，谢谢。

作者：周永恒
出处：http://www.cnblogs.com/Zhouyongh  

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。