What are the implications of creating WPF controls on background thread?

Question

So, lets say I have STA thread running on background and I create a user control there.

How functional it is going to be? What are the limitations?

_workingThread = new Thread(() =>
{ 
   //so far so good
   var myControl = new MyCustomControl();

   //what happens if i set DataContext? Will databinding work? 
   //It looks like it does, but I am not entirely sure.
   myControl.DataContext = new MyViewModel();

   //if databinding works, can I assume that at this point 
   //myControl's properties are already updated?

   //what happens exactly if I invoke a delgate using Dispatcher property?
   myControl.Dispatcher.Invoke(SomeMethod);
   //or current dispatcher?
   Dispatcher.CurrentDispatcher.BeginInvoke(SomeOtherMethod);        
});
_workingThread.SetApartmentState(ApartmentState.STA);
_workingThread.Start();

To answer the question why: there is a component in .Net called XpsDocument which allows you to write visuals into xps file. I don't see a reason, why I should do it on UI thread.

Answer 1

Here is example of WPF app, which creates Window in new STA Thread. I don't see any problem with it. I printed out some things: Thread name, ThreadId and Counter (changes via INotifyPropertyChanged). Also I change stackPanelCounter's background from timer Dispatcher.BeginInvoke. XAML:

<Window x:Class="WpfWindowInAnotherThread.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        mc:Ignorable="d"
        SizeToContent="WidthAndHeight" WindowStartupLocation="CenterScreen" Title="WPF: Windows and Threads">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto"/>
            <RowDefinition />
        </Grid.RowDefinitions>
        <StackPanel Grid.Row="0" Orientation="Vertical">
            <TextBlock Text="{Binding ThreadId, StringFormat='ThreadId: {0}'}" />
            <TextBlock Text="{Binding ThreadName, StringFormat='ThreadName: {0}'}" />
        </StackPanel>
        <StackPanel Grid.Row="1" Orientation="Horizontal" Name="stackPanelCounter">
            <TextBlock Text="Counter: " />
            <TextBlock Text="{Binding Counter}" />
        </StackPanel>
        <StackPanel Grid.Row="2">
            <Button Name="btnStartInNewThread" Content="Start window in new Thread"
                    Click="btnStartInNewThread_Click"/>
            <Button Name="btnStartTheSameThread"
                    Content="Start window in the same Thread"
                    Click="btnStartTheSameThread_Click" />
        </StackPanel>
    </Grid>
</Window>

Code:

using System;
using System.ComponentModel;
using System.Threading;
using System.Windows;
using System.Windows.Media;
using System.Windows.Threading;

namespace WpfWindowInAnotherThread
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window, INotifyPropertyChanged
    {
        static int _threadNumber = 0;
        readonly Timer _timer;
        int _Counter;

        public event PropertyChangedEventHandler PropertyChanged = delegate { };

        public int ThreadId
        {
            get { return Thread.CurrentThread.ManagedThreadId; }
        }
        public string ThreadName
        {
            get { return Thread.CurrentThread.Name; }
        }
        public int Counter
        {
            get { return _Counter; }
            set { _Counter = value; PropertyChanged(this, new PropertyChangedEventArgs("Counter")); }
        }

        public MainWindow()
        {
            DataContext = this;
            _timer = new Timer((o) => {
                Counter++;
                MainWindow wnd = o as MainWindow;
                wnd.Dispatcher.BeginInvoke(new Action<MainWindow>(ChangeStackPanelBackground), wnd);
            }, this, 0, 200);
            InitializeComponent();
        }
        private void btnStartTheSameThread_Click(object sender, RoutedEventArgs e)
        {
            MainWindow mainWnd = new MainWindow();
            mainWnd.Show();
        }
        private void btnStartInNewThread_Click(object sender, RoutedEventArgs e)
        {
            Thread thread = new Thread(new ThreadStart(ThreadMethod));
            thread.SetApartmentState(ApartmentState.STA);
            thread.IsBackground = true;
            thread.Start();
        }
        private static void ThreadMethod()
        {
            Thread.CurrentThread.Name = "MainWindowThread# " + _threadNumber.ToString();
            Interlocked.Increment(ref _threadNumber);

            MainWindow mainWnd = new MainWindow();
            mainWnd.Show();

            Dispatcher.Run();
        }
        private static void ChangeStackPanelBackground(MainWindow wnd)
        {
            Random rnd = new Random(Environment.TickCount);
            byte[] rgb = new byte[3];
            rnd.NextBytes(rgb);
            wnd.stackPanelCounter.Background = new SolidColorBrush(Color.FromArgb(0xFF, rgb[0], rgb[1], rgb[2]));
        }
    }
}

Answer 2

I spent some time testing things out, and I think Clemens's comment was accurate. Key points are:

1. myControl.Dispatcher and Dispatcher.CurrentDispatcher are one and the same, both hold a reference to dispatcher of background thread. No surprises here.

2. In general controls will not behave correctly without dispatcher running, because Dispatcher.BeginInvoke calls will not be processed. You have two options. Either call Dispatcher.Run() on background thread and create your controls using invokes:

   _backgroundDispatcher.BeginInvoke(new Action(() => 
   {
      var myControl = new MyCustomControl();
      //do stuff
   })); 
   

   or manually push dispatcher frame every time you want to process dispatcher queue and "refresh" your control. When it comes to building XPS pages, both approaches are viable.

3. Data bindings do work, even when control is created on background thread. However in some cases they are not applied instantly and you might have to wait for dispatcher to process it's queue.