(转载自http://www.cnblogs.com/Kevin-moon/archive/2009/01/13/1374353.html)

(英文相关:http://www.codeproject.com/KB/threads/SynchronizationContext.aspx)

理解SynchronizationContext

---

　　SynchronizationContext 类是一个基类，可提供不带同步的自由线程上下文。 此类实现的同步模型的目的是使公共语言运行库内部的异步/同步操作能够针对不同的异步模型采取正确的行为。此模型还简化了托管应用程序为在不同的同步环境下正常工作而必须遵循的一些要求。同步模型的提供程序可以扩展此类并为这些方法提供自己的实现。(来自MSDN)
　　简而言之就是允许一个线程和另外一个线程进行通讯，SynchronizationContext在通讯中充当传输者的角色。另外这里有个地方需要清楚的，不是每个线程都附加SynchronizationContext这个对象，只有UI线程是一直拥有的。
　　这里你可能有个问题：对于UI线程来说，是如何将SynchronizationContext这个对象附加到线程上的呢？！OK，我们先从下面的代码开始，

[STAThread]
static void Main()
{
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);// let's check the context here
    var context = SynchronizationContext.Current;
    if (context == null)
        MessageBox.Show("No context for this thread");
    else
        MessageBox.Show("We got a context");// create a form
    Form1 form = new Form1();// let's check it again after creating a form
    context = SynchronizationContext.Current;if (context == null)
        MessageBox.Show("No context for this thread");
    else
        MessageBox.Show("We got a context");if (context == null)
        MessageBox.Show("No context for this thread");

    Application.Run(

new Form1());
}

---

　　应用程序有两个线程：线程A和线程B，不过线程B比较特殊，它属于UI线程，当这两个线程同时运行的时候，线程A有个需求："修改UI对象的属性"，这时候如果你是线程A，你会如何去完成需求呢？！

第一种方式：     

     在线程A上面直接去操作UI对象，这是线程B说："线程A，你真xx，你不知道我的特殊嘛！"，然后直接抛给线程A一个异常信息，线程A得到异常后，一脸的无辜和无奈.....!

第二种方式：
　　

InvokeRequired？！是的，当然没问题。(解释下，InvokeRequired属性是每个Control对象都具有的属性，它会返回true和false，当是true的时候，表示它在另外一个线程上面，这是必须通过Invoke,BeginInvoke这些方法来调用更新UI对象的方法，当是false的时候，有两种情况，1：位于当前线程上面，可以通过直接去调用修改UI对象的方法，2：位于不同的线程上，不过控件或窗体的句柄不存在。对于句柄是否存在的判断，可以通过IsHandleCreated来获取，如果句柄不存在，是不能调用Invoke...这些方法的，这时候你必须等待句柄的创建）
通过InvokeRequired的实现方式如下：

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Threading;public class MyFormControl : Form
   {
      public delegate void AddListItem(String myString);
      public AddListItem myDelegate;
      private Button myButton;
      private Thread myThread;
      private ListBox myListBox;
      public MyFormControl()
      {
         myButton = new Button();
         myListBox = new ListBox();
         myButton.Location = new Point(72, 160);
         myButton.Size = new Size(152, 32);
         myButton.TabIndex = 1;
         myButton.Text = "Add items in list box";
         myButton.Click += new EventHandler(Button_Click);
         myListBox.Location = new Point(48, 32);
         myListBox.Name = "myListBox";
         myListBox.Size = new Size(200, 95);
         myListBox.TabIndex = 2;
         ClientSize = new Size(292, 273);
         Controls.AddRange(new Control[] {myListBox,myButton});
         Text = " 'Control_Invoke' example ";
         myDelegate = new AddListItem(AddListItemMethod);
      }
      static void Main()
      {
         MyFormControl myForm = new MyFormControl();
         myForm.ShowDialog();
      }
      public void AddListItemMethod(String myString)
      {
            myListBox.Items.Add(myString);
      }
      private void Button_Click(object sender, EventArgs e)
      {
         myThread = new Thread(new ThreadStart(ThreadFunction));
         myThread.Start();
      }
      private void ThreadFunction()
      {
         MyThreadClass myThreadClassObject  = new MyThreadClass(this);
         myThreadClassObject.Run();
      }
   }
   public class MyThreadClass
   {
      MyFormControl myFormControl1;
      public MyThreadClass(MyFormControl myForm)
      {
         myFormControl1 = myForm;
      }
      String myString;public void Run()
      {
         for (int i = 1; i <= 5; i++)
         {
            myString = "Step number " + i.ToString() + " executed";
            Thread.Sleep(400);
            // Execute the specified delegate on the thread that owns
            // 'myFormControl1' control's underlying window handle with
            // the specified list of arguments.
            myFormControl1.Invoke(myFormControl1.myDelegate,
                                   new Object[] {myString});
         }
      }
   }

    不过这里存在一个有争论的地方：这种方式必须通过调用Control的Invoke方法来实现，这就是说调用的地方必须有一个Control的引用存在。
　　看下MyThreadClass类，这个类中就存在MyFormControl的引用对象。其实如果这个类放在这里是没有任务不妥之处的，但是如果把MyThreadClass类放在业务层，这时候问题就出现了，从设计角度来说，业务层是不允许和UI有任何关系，所以MyFormControl的引用对象绝对不能存在于MyThreadClass类，但是不让它存在，更新UI控件的需求就满足不了，这种情况下，我们如何做到一种最佳方案呢！？

第三种方式：
　　本文的主角：SynchronizationContext登场了。解释之前，先让下面的代码做下铺垫，

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }private void mToolStripButtonThreads_Click(object sender, EventArgs e)
    {
        // let's see the thread id
        int id = Thread.CurrentThread.ManagedThreadId;
        Trace.WriteLine("mToolStripButtonThreads_Click thread: " + id);// grab the sync context associated to this
        // thread (the UI thread), and save it in uiContext
        // note that this context is set by the UI thread
        // during Form creation (outside of your control)
        // also note, that not every thread has a sync context attached to it.
        SynchronizationContext uiContext = SynchronizationContext.Current;// create a thread and associate it to the run method
        Thread thread = new Thread(Run);// start the thread, and pass it the UI context,
        // so this thread will be able to update the UI
        // from within the thread
        thread.Start(uiContext);
    }private void Run(object state)
    {
        // lets see the thread id
        int id = Thread.CurrentThread.ManagedThreadId;
        Trace.WriteLine("Run thread: " + id);// grab the context from the state
        SynchronizationContext uiContext = state as SynchronizationContext;for (int i = 0; i < 1000; i++)
        {
            // normally you would do some code here
            // to grab items from the database. or some long
            // computation
            Thread.Sleep(10);// use the ui context to execute the UpdateUI method,
            // this insure that the UpdateUI method will run on the UI thread.

            uiContext.Post(UpdateUI, "line " + i.ToString());
        }
    }/// <summary>
    /// This method is executed on the main UI thread.
    /// </summary>
    private void UpdateUI(object state)
    {
        int id = Thread.CurrentThread.ManagedThreadId;
        Trace.WriteLine("UpdateUI thread:" + id);
        string text = state as string;
        mListBox.Items.Add(text);
    }
}

运行结果：

mToolStripButtonThreads_Click thread: 10
Run thread: 3
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
 (x1000 times)

---

首先看下异常处理的情况

private void Run(object state)
{
    // let's see the thread id
    int id = Thread.CurrentThread.ManagedThreadId;
    Trace.WriteLine("Run thread: " + id);// grab the context from the state
    SynchronizationContext uiContext = state as SynchronizationContext;for (int i = 0; i < 1000; i++)
    {
        Trace.WriteLine("Loop " + i.ToString());
        // normally you would do some code here
        // to grab items from the database. or some long
        // computation
        Thread.Sleep(10);// use the ui context to execute the UpdateUI method, this insure that the
        // UpdateUI method will run on the UI thread.

        try
        {
            uiContext.Send(UpdateUI, "line " + i.ToString());
        }
        catch (Exception e)
        {
            Trace.WriteLine(e.Message);
        }
    }
}/// <summary>
/// This method is executed on the main UI thread.
/// </summary>
private void UpdateUI(object state)
{
    throw new Exception("Boom");
}

　　 当你运行的时候， 你可能希望在UI线程上面去抛出，但是结果往往出忽你的意料，异常信息都在Run方法的线程上被捕获了。这时候你可能想问：WHY？！
　　 解释之前，我们先看下，Send VS Post的结果:
　　 Send 方法启动一个同步请求以发送消息
　　 Post 方法启动一个异步请求以发送消息。    
　　 哈哈，异常处理的答案迎韧而解了吧！