Как правильно работать с 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);
    }
}

// Type: System.ComponentModel.BackgroundWorker
// Assembly: System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// Assembly location: C:\Windows\Microsoft.NET\Framework\v4.0.30319\System.dll
 
using System;
using System.Runtime;
using System.Security.Permissions;
using System.Threading;
 
namespace System.ComponentModel
{
  [SRDescription("BackgroundWorker_Desc")]
  [DefaultEvent("DoWork")]
  [HostProtection(SecurityAction.LinkDemand, SharedState = true)]
  public class BackgroundWorker : Component
  {
    private static readonly object doWorkKey = new object();
    private static readonly object runWorkerCompletedKey = new object();
    private static readonly object progressChangedKey = new object();
    private bool canCancelWorker;
    private bool workerReportsProgress;
    private bool cancellationPending;
    private bool isRunning;
    private AsyncOperation asyncOperation;
    private readonly BackgroundWorker.WorkerThreadStartDelegate threadStart;
    private readonly SendOrPostCallback operationCompleted;
    private readonly SendOrPostCallback progressReporter;
 
    [Browsable(false)]
    [SRDescription("BackgroundWorker_CancellationPending")]
    public bool CancellationPending
    {
      [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get
      {
        return this.cancellationPending;
      }
    }
 
    [SRDescription("BackgroundWorker_IsBusy")]
    [Browsable(false)]
    public bool IsBusy
    {
      [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get
      {
        return this.isRunning;
      }
    }
 
    [SRCategory("PropertyCategoryAsynchronous")]
    [DefaultValue(false)]
    [SRDescription("BackgroundWorker_WorkerReportsProgress")]
    public bool WorkerReportsProgress
    {
      [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get
      {
        return this.workerReportsProgress;
      }
      [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] set
      {
        this.workerReportsProgress = value;
      }
    }
 
    [SRCategory("PropertyCategoryAsynchronous")]
    [DefaultValue(false)]
    [SRDescription("BackgroundWorker_WorkerSupportsCancellation")]
    public bool WorkerSupportsCancellation
    {
      [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get
      {
        return this.canCancelWorker;
      }
      [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] set
      {
        this.canCancelWorker = value;
      }
    }
 
    [SRCategory("PropertyCategoryAsynchronous")]
    [SRDescription("BackgroundWorker_DoWork")]
    public event DoWorkEventHandler DoWork
    {
      add
      {
        this.Events.AddHandler(BackgroundWorker.doWorkKey, (Delegate) value);
      }
      remove
      {
        this.Events.RemoveHandler(BackgroundWorker.doWorkKey, (Delegate) value);
      }
    }
 
    [SRDescription("BackgroundWorker_ProgressChanged")]
    [SRCategory("PropertyCategoryAsynchronous")]
    public event ProgressChangedEventHandler ProgressChanged
    {
      add
      {
        this.Events.AddHandler(BackgroundWorker.progressChangedKey, (Delegate) value);
      }
      remove
      {
        this.Events.RemoveHandler(BackgroundWorker.progressChangedKey, (Delegate) value);
      }
    }
 
    [SRCategory("PropertyCategoryAsynchronous")]
    [SRDescription("BackgroundWorker_RunWorkerCompleted")]
    public event RunWorkerCompletedEventHandler RunWorkerCompleted
    {
      add
      {
        this.Events.AddHandler(BackgroundWorker.runWorkerCompletedKey, (Delegate) value);
      }
      remove
      {
        this.Events.RemoveHandler(BackgroundWorker.runWorkerCompletedKey, (Delegate) value);
      }
    }
 
    static BackgroundWorker()
    {
    }
 
    public BackgroundWorker()
    {
      this.threadStart = new BackgroundWorker.WorkerThreadStartDelegate(this.WorkerThreadStart);
      this.operationCompleted = new SendOrPostCallback(this.AsyncOperationCompleted);
      this.progressReporter = new SendOrPostCallback(this.ProgressReporter);
    }
 
    public void CancelAsync()
    {
      if (!this.WorkerSupportsCancellation)
        throw new InvalidOperationException(SR.GetString("BackgroundWorker_WorkerDoesntSupportCancellation"));
      this.cancellationPending = true;
    }
 
    protected virtual void OnDoWork(DoWorkEventArgs e)
    {
      DoWorkEventHandler workEventHandler = (DoWorkEventHandler) this.Events[BackgroundWorker.doWorkKey];
      if (workEventHandler == null)
        return;
      workEventHandler((object) this, e);
    }
 
    protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs e)
    {
      RunWorkerCompletedEventHandler completedEventHandler = (RunWorkerCompletedEventHandler) this.Events[BackgroundWorker.runWorkerCompletedKey];
      if (completedEventHandler == null)
        return;
      completedEventHandler((object) this, e);
    }
 
    protected virtual void OnProgressChanged(ProgressChangedEventArgs e)
    {
      ProgressChangedEventHandler changedEventHandler = (ProgressChangedEventHandler) this.Events[BackgroundWorker.progressChangedKey];
      if (changedEventHandler == null)
        return;
      changedEventHandler((object) this, e);
    }
 
    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
    public void ReportProgress(int percentProgress)
    {
      this.ReportProgress(percentProgress, (object) null);
    }
 
    public void ReportProgress(int percentProgress, object userState)
    {
      if (!this.WorkerReportsProgress)
        throw new InvalidOperationException(SR.GetString("BackgroundWorker_WorkerDoesntReportProgress"));
      ProgressChangedEventArgs changedEventArgs = new ProgressChangedEventArgs(percentProgress, userState);
      if (this.asyncOperation != null)
        this.asyncOperation.Post(this.progressReporter, (object) changedEventArgs);
      else
        this.progressReporter((object) changedEventArgs);
    }
 
    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
    public void RunWorkerAsync()
    {
      this.RunWorkerAsync((object) null);
    }
 
    public void RunWorkerAsync(object argument)
    {
      if (this.isRunning)
        throw new InvalidOperationException(SR.GetString("BackgroundWorker_WorkerAlreadyRunning"));
      this.isRunning = true;
      this.cancellationPending = false;
      this.asyncOperation = AsyncOperationManager.CreateOperation((object) null);
      this.threadStart.BeginInvoke(argument, (AsyncCallback) null, (object) null);
    }
 
    private void AsyncOperationCompleted(object arg)
    {
      this.isRunning = false;
      this.cancellationPending = false;
      this.OnRunWorkerCompleted((RunWorkerCompletedEventArgs) arg);
    }
 
    private void ProgressReporter(object arg)
    {
      this.OnProgressChanged((ProgressChangedEventArgs) arg);
    }
 
    private void WorkerThreadStart(object argument)
    {
      object result = (object) null;
      Exception error = (Exception) null;
      bool cancelled = false;
      try
      {
        DoWorkEventArgs e = new DoWorkEventArgs(argument);
        this.OnDoWork(e);
        if (e.Cancel)
          cancelled = true;
        else
          result = e.Result;
      }
      catch (Exception ex)
      {
        error = ex;
      }
      this.asyncOperation.PostOperationCompleted(this.operationCompleted, (object) new RunWorkerCompletedEventArgs(result, error, cancelled));
    }
 
    private delegate void WorkerThreadStartDelegate(object argument);
  }
}

// Type: System.ComponentModel.AsyncOperation
// Assembly: System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// Assembly location: C:\Windows\Microsoft.NET\Framework\v4.0.30319\System.dll
 
using System;
using System.Runtime;
using System.Security.Permissions;
using System.Threading;
 
namespace System.ComponentModel
{
  [HostProtection(SecurityAction.LinkDemand, SharedState = true)]
  public sealed class AsyncOperation
  {
    private SynchronizationContext syncContext;
    private object userSuppliedState;
    private bool alreadyCompleted;
 
    public object UserSuppliedState
    {
      [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get
      {
        return this.userSuppliedState;
      }
    }
 
    public SynchronizationContext SynchronizationContext
    {
      [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] get
      {
        return this.syncContext;
      }
    }
 
    private AsyncOperation(object userSuppliedState, SynchronizationContext syncContext)
    {
      this.userSuppliedState = userSuppliedState;
      this.syncContext = syncContext;
      this.alreadyCompleted = false;
      this.syncContext.OperationStarted();
    }
 
    ~AsyncOperation()
    {
      if (this.alreadyCompleted || this.syncContext == null)
        return;
      this.syncContext.OperationCompleted();
    }
 
    public void Post(SendOrPostCallback d, object arg)
    {
      this.VerifyNotCompleted();
      this.VerifyDelegateNotNull(d);
      this.syncContext.Post(d, arg);
    }
 
    public void PostOperationCompleted(SendOrPostCallback d, object arg)
    {
      this.Post(d, arg);
      this.OperationCompletedCore();
    }
 
    public void OperationCompleted()
    {
      this.VerifyNotCompleted();
      this.OperationCompletedCore();
    }
 
    internal static AsyncOperation CreateOperation(object userSuppliedState, SynchronizationContext syncContext)
    {
      return new AsyncOperation(userSuppliedState, syncContext);
    }
 
    private void OperationCompletedCore()
    {
      try
      {
        this.syncContext.OperationCompleted();
      }
      finally
      {
        this.alreadyCompleted = true;
        GC.SuppressFinalize((object) this);
      }
    }
 
    private void VerifyNotCompleted()
    {
      if (this.alreadyCompleted)
        throw new InvalidOperationException(SR.GetString("Async_OperationAlreadyCompleted"));
    }
 
    private void VerifyDelegateNotNull(SendOrPostCallback d)
    {
      if (d == null)
        throw new ArgumentNullException(SR.GetString("Async_NullDelegate"), "d");
    }
  }
}