Ensuring that things run on the UI thread in WPF

Question

I'm building a WPF application. I'm doing some async communication with the server side, and I use event aggregation with Prism on the client. Both these things results in new threads to be spawned which are not the UI thread. If I attempt to do "WPF operations" on these callback and event handler threads the world will fall apart, which it now has started doing.

First I met problems trying to create some WPF objects in the callback from server. I was told that the thread needed to run in STA mode. Now I'm trying to update some UI data in a Prism event handler, and I'm told that:

The caller cannot access this thread because a different thread owns it.

So; what's the key to getting things right in WPF? I've read up on the WPF Dispatcher in this MSDN post. I'm starting to get it, but I'm no wizard yet.

1. Is the key to always use Dispatcher.Invoke when I need to run something which I'm not sure will be called on the UI thread?
2. Does it matter if it actually was called on the UI thread, and I do Dispatcher.Invoke anyway?
3. Dispatcher.Invoke = synchronously. Dispathcher.BeginInvoke = async?
4. Will Dispatcher.Invoke request the UI thread, and then stop to wait for it? Is it bad practice and risk of less responsive programs?
5. How do I get the dispatcher anyway? Will Dispatcher.CurrentDispatcher always give me the dispatcher representing the UI thread?
6. Will there exist more than one Dispatcher, or is "Dispatcher" basically the same as the UI thread for the application?
7. And what's the deal with the BackgroundWorker? When do I use this instead? I assume this is always async?
8. Will everything that runs on the UI thread (by being Invoked) be run in STA apartment mode? I.e. if I have something that requires to be run in STA mode - will Dispatcher.Invoke be sufficient?

Anyone wanna clearify things for me? Any related recommendations, etc? Thanks!

Solution

Going over each of your questions, one by one:

1. Not quite; you should only invoke onto the UI thread when necessary. See #2.
2. Yes, it does matter. You should not just automatically Invoke everything. The key is to only invoke onto the UI thread if necessary. To do this, you can use the Dispatcher.CheckAccess method.
3. That is correct.
4. Also correct, and yes, you do run the risk of less responsive programs. Most of the time, you are not going to be looking at a severe performance hit (we're talking about milliseconds for a context switch), but you should only Invoke if necessary. That being said, at some points it is unavoidable, so no, I would not say it is bad practice at all. It is just one solution to a problem that you will encounter every now and then.
5. In every case I have seen, I have made due with Dispatcher.CurrentDispatcher. For complex scenarios, this may not be sufficient, but I (personally) have not seen them.
6. Not entirely correct, but this line of thinking will not do any harm. Let me put it this way: the Dispatcher can be used to gain access to the UI thread for the application. But it is not in and of itself the UI thread.
7. BackgroundWorker is generally used when you have a time-consuming operation and want to maintain a responsive UI while running that operation in the background. Normally you do not use BackgroundWorker instead of Invoke, rather, you use BackgroundWorker in conjunction with Invoke. That is, if you need to update some UI object in your BackgroundWorker, you can Invoke onto the UI thread, perform the update, and then return to the original operation.
8. Yes. The UI thread of a WPF application, by definition, must be running in a single-threaded apartment.

There's a lot to be said about BackgroundWorker, I'm sure many questions are already devoted to it, so I won't go into too much depth. If you're curious, check out the MSDN page for BackgroundWorker class.

Comments

[stiank81]

Thanks a lot Charlie! This is really clarifying and helpful!

[stiank81]

Added an 8th question to the list. I hope you can update your answer to include it :-)

[Ray Burns]

Good answers (+1), but I'm going to disagree with part of your answer #2. Calling Dispatcher.CheckAccess is almost always a bad idea. If you want Send priority, just use it: Dispatcher.Invoke will recognize it make a direct call when possible. On the other hand, if your task is lower priority you won't want to call CheckAccess anyway. The only exception to this would be if you want to vary your task's priority depending on context. If so, the best way is: Dispatcher.Invoke(Dispatcher.CheckAccess() ? DispatcherPriority.Send : DispatcherPriority.Render, ...)

[Ray Burns]

Another clarification to #5 and #6: Conceptually every thread has its own Dispatcher (1-1 relationship). Dispatcher.CurrentDispatcher returns the Dispatcher of the current thread. If called from a UI thread it will return that thread's Dispatcher. If called from a background thread, it will return a Dispatcher for the background thread instead. An application can have multiple UI threads, so the safest way to access a DispatcherObject is through its DispatcherObject.Dispatcher property. But if your application has only one UI thread, Application.Current.Dispatcher will do the trick.