Multithreading in WPF Part I

Multithreading means executing more than one code block at a time .Usually it is used to create more responsive user interface(User interface that is not freezed up) ,although it can be used for other tasks as well like performing some action while still waiting for a response from web service.

WPF supports a Single Threaded Apartment Model(STA) like the windows forms which introduces following constraints in a WPF application.

1. The thread that creates a WPF UI element owns the elements and other threads can not interact with the UI elements directly,this is known as thread affinity.
 

2. WPF objects that have thread affinity derive from DispatcherObject at some point
   in their class hierarchy

Usually one thread runs entire WPF application and owns all the application objects.
In the following sections, you'll explore the DispatcherObject class and learn the simplest way to perform an asynchronous operation in a WPF application.

The Dispatcher

A dispatcher manages the work that takes place in a WPF application. The dispatcher owns the application thread and hence all the objects that belong to the thread.

If on a new thread we create a UIelement then Dispatcher is also created.

For example if we create a new TextBox on a new thread then Dispatcher object is created for us.

The dispatcher class is found in the System.Windows.Threading.Dispatcher class. All the dispatcher related objects are also found in the small System.Windows.Threading namespace, which is a new WPF namespace.

Most of the time you will be intracting with DispatcherObject (a DispatcherObject is simply an object that's linked to a dispatcher) because
All UIelements derive from this class.

The DispatcherObject includes VerifyAccess method that throws an InvalidOperationException if wrong thread tries to access an application object.

WPF objects call VerifyAccess() frequently to protect that they do not execute in wrong thread for very long.

If we create a new thread for a long running task and that thread accesses a WPF element then this thread will throw an exception since a new thread can not access a WPF element that belongs to another thread.

If we execute the below code we will get an exception like:
"Invalid Operation Exception:The calling thread cannot access this object because a different thread owns it."

public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            Thread thread = new Thread(Update);
            thread.Start();
         }

        private void Update()
        {
            // Simulate some work taking place
            Thread.Sleep(TimeSpan.FromSeconds(5));
            txtName.Text = "Here is some new text.";
        }
    }




We can use a dispatcher to update the textbox from a new thread without throwing an exception.

private void Update()
        {
            // Simulate some work taking place
            Thread.Sleep(TimeSpan.FromSeconds(5));
            this.Dispatcher.BeginInvoke(DispatcherPriority.Normal,
                        (ThreadStart)delegate()
                        {
                            txtName.Text = "Here is some new text.";
                        }
                          );
           
        }

The Dispatcher.BeginInvoke() method takes two parameters. The first indicates the priority of the task.The second BeginInvoke() parameter is a delegate that points to the method with the code you want to execute