Multithreading means executing more than one code block at a time. Usually it is used to create a more responsive user interface(a User interface that is not frozen up) ,although it can be used for other tasks as well, like performing some action while still waiting for a response from a web service.
WPF supports a Single-Threaded Apartment Model(STA) like Windows Forms, which introduces the following constraints in a WPF application.
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.
WPF objects that have thread affinity derive from DispatcherObject at some point
in their class hierarchy
Usually, one thread runs the 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 we create a UIElement on a new thread, a Dispatcher is also created.
For example, if we create a new TextBox on a new thread, then a 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 interacting with a DispatcherObject (a DispatcherObject is simply an object that's linked to a dispatcher) because
All UIelements derive from this class.
The DispatcherObject includes a VerifyAccess method that throws an InvalidOperationException if the 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 code below, we will get an exception like: Invalid Operation Exception
The calling thread cannot access this object because a different thread owns it.
publicpartialclassMainWindow:Window
{
publicMainWindow()
{
InitializeComponent();
Threadthread =newThread(Update);
thread.Start();
}
private void Update()
{
// Simulate some work taking place
Thread.Sleep(TimeSpan.FromSeconds(5));
txtName.Text = "Here is some new text.";
}
}
![image1.gif]()
We can use a dispatcher to update the textbox from a new thread without throwing an exception.
privatevoidUpdate()
{
// 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.