UI线程模型的背景信息

通常一个应用程序有一个“主”UI线程...它可能有0个或多个后台/辅助/非UI线程，您（或.NET运行时/框架）在这些线程中进行后台工作。
（... WPF中还有另一个特殊线程，称为渲染线程，但我现在将跳过它...）
例如，简单的WPF应用程序可能具有以下线程列表：

一个简单的WinForms应用程序可能具有以下线程列表：

当你创建一个元素时，它被绑定到一个特定的Dispatcher &线程，并且只能从与Dispatcher关联的线程安全地访问。
如果您尝试从不同的线程访问对象的属性或方法，通常会得到异常，例如在WPF中：

在Windows窗体中：

• Detecting whether on UI thread in WPF and Winforms
• http://www.perceler.com/articles1.php?art=crossthreads1

对UI的任何修改都需要在创建UI元素的同一个线程上执行......因此，后台线程使用Invoke/BeginInvoke在UI线程上运行该工作。

演示在非UI线程上创建元素的问题

<Window x:Class="WpfApplication9.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525" Loaded="Window_Loaded">
    <StackPanel x:Name="mystackpanel">

    </StackPanel>
</Window>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.ComponentModel;
using System.Threading;
using System.Windows.Threading;

namespace WpfApplication9
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        Thread m_thread1;
        Thread m_thread2;
        Thread m_thread3;
        Thread m_thread4;

        public MainWindow()
        {
            InitializeComponent();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            CreateAndAddElementInDifferentWays();
        }

        void CreateAndAddElementInDifferentWays()
        {
            string text = "created in ui thread, added in ui thread [Main STA]";
            System.Diagnostics.Debug.WriteLine(text);

            CreateAndAddTextChild(text);

            // Do NOT use any Joins with any of these threads, otherwise you will get a
            // deadlock on any "Invoke" call you do.

            // To better observe and focus on the behaviour when creating and
            // adding an element from differently configured threads, I suggest
            // you pick "one" of these and do a recompile/run.

            ParameterizedThreadStart paramthreadstart1 = new ParameterizedThreadStart(this.WorkCreatedOnThreadAddedOnThread);
            m_thread1 = new Thread(paramthreadstart1);
            m_thread1.SetApartmentState(ApartmentState.STA);
            m_thread1.Start("[STA]");

            //ParameterizedThreadStart paramthreadstart2 = new ParameterizedThreadStart(this.WorkCreatedOnThreadAddedOnUIThread);
            //m_thread2 = new Thread(paramthreadstart2);
            //m_thread2.SetApartmentState(ApartmentState.STA);
            //m_thread2.Start("[STA]");

            //ParameterizedThreadStart paramthreadstart3 = new ParameterizedThreadStart(this.WorkCreatedOnThreadAddedOnThread);
            //m_thread3 = new Thread(paramthreadstart3);
            //m_thread3.SetApartmentState(ApartmentState.MTA);
            //m_thread3.Start("[MTA]");

            //ParameterizedThreadStart paramthreadstart4 = new ParameterizedThreadStart(this.WorkCreatedOnThreadAddedOnUIThread);
            //m_thread4 = new Thread(paramthreadstart4);
            //m_thread4.SetApartmentState(ApartmentState.MTA);
            //m_thread4.Start("[MTA]");
        }

        //----------------------------------------------------------------------

        void WorkCreatedOnThreadAddedOnThread(object parameter)
        {
            string threadingmodel = parameter as string;

            string text = "created in worker thread, added in background thread, " + threadingmodel;
            System.Diagnostics.Debug.WriteLine(text);

            CreateAndAddTextChild(text);
        }

        void WorkCreatedOnThreadAddedOnUIThread(object parameter)
        {
            string threadingmodel = parameter as string;

            string text = "created in worker thread, added in ui thread via invoke" + threadingmodel;
            System.Diagnostics.Debug.WriteLine(text);

            TextBlock tb = CreateTextBlock(text);
            if (tb != null)
            {
                // You can alternatively use .Invoke if you like!

                DispatcherOperation dispop = Dispatcher.BeginInvoke(new Action(() =>
                {
                    // Get this work done on the main UI thread.

                    AddTextBlock(tb);
                }));

                if (dispop.Status != DispatcherOperationStatus.Completed)
                {
                    dispop.Wait();
                }
            }
        }

        //----------------------------------------------------------------------

        public TextBlock CreateTextBlock(string text)
        {
            System.Diagnostics.Debug.WriteLine("[CreateTextBlock]");

            try
            {
                TextBlock tb = new TextBlock();
                tb.Text = text;
                return tb;
            }
            catch (InvalidOperationException ex)
            {
                // will always exception, using this to highlight issue.
                System.Diagnostics.Debug.WriteLine(ex.Message);
            }

            return null;
        }

        public void AddTextBlock(TextBlock tb)
        {
            System.Diagnostics.Debug.WriteLine("[AddTextBlock]");

            try
            {
                mystackpanel.Children.Add(tb);
            }
            catch (InvalidOperationException ex)
            {
                System.Diagnostics.Debug.WriteLine(ex.Message);
            }
        }

        public void CreateAndAddTextChild(string text)
        {
            TextBlock tb = CreateTextBlock(text);
            if (tb != null)
                AddTextBlock(tb);
        }
    }
}

辅助UI线程，也称为“在另一个线程上创建顶级窗口”

可以创建辅助UI线程，只要将线程标记为使用STA单元模型，并创建Dispatcher（例如，使用Dispatcher.Current）和启动“run”循环（Dispatcher.Run()），以便Dispatcher可以为在该线程上创建的UI元素提供消息服务。

• Dispatcher to Thread relationships in WPF
• http://eprystupa.wordpress.com/2008/07/28/running-wpf-application-with-multiple-ui-threads/
• http://www.diranieh.com/NET_WPF/Threading.htm

但是，在一个UI线程中创建的元素不能放入在不同UI线程上创建的另一个元素的逻辑/可视树中。

混合在不同UI线程上创建的元素的解决方法

有一个有限的解决方法，它可以为您提供一些功能，通过使用HostVisual，将在一个UI线程中创建的元素的呈现与在另一个线程中创建的可视树组合在一起。请参见此示例：

• https://dwayneneed.github.io/wpf/2007/04/26/multithreaded-ui-hostvisual.html

不，UserControl是绑定到UI线程的。即使您能够在其他地方初始化它们，您也会遇到将它们添加到主UI的问题，因为它们属于不同的线程。

您可以跨不同的线程拆分可视化树的呈现。
请参阅本文，以获得更好的解释和渲染视频输出的示例。http://blogs.msdn.com/b/dwayneneed/archive/2007/04/26/multithreaded-ui-hostvisual.aspx
但是，只有当Visual的实际渲染在其他地方实现时，或者在WPF应用程序中（例如将Direct3D场景渲染为Visual），这样做在技术上非常奇怪时，才真正合理。
正如本文中提到的，这里需要注意的是，如果辅助线程呈现WPF XAML，则会丢失输入事件，因为路由的事件无法跨越线程边界。