Difference between Synchronization Context and Dispatcher
.net, c#
Solution
They both have similar effects, but `SynchronizationContext` is more generic.
`Application.Current.Dispatcher` refers to the WPF dispatcher of the application, and using `Invoke` on that executes the delegate on the main thread of that application.
`SynchronizationContext.Current` on the other hand returns different implementations of depending on the current thread. When called on the UI thread of a WPF application it returns a `SynchronizationContext` that uses the dispatcher, when called in on the UI thread of a WinForms application it returns a different one.
You can see the classes inheriting from `SynchronizationContext` in its MSDN documentation: WindowsFormsSynchronizationContext and DispatcherSynchronizationContext.
One thing to be aware about when using `SynchronizationContext` is that it returns the synchronization context of the current thread. If you want to use the synchronization context of another thread, e.g. the UI thread, you have to first get its context and store it in a variable:
public void Control_Event(object sender, EventArgs e)
{
var uiContext = SynchronizationContext.Current;
Task.Run(() =>
{
// do some work
uiContext.Post(/* update UI controls*/);
}
}
This does not apply to `Application.Current.Dispatcher`, which always returns the dispatcher for the application.
Problem
I am using `Dispatcher` to switch to UI thread from external like this ``` Application.Current.Dispatcher.Invoke(myAction); ``` But I saw on some forums people have advised to use `SynchronizationContext` instead of `Dispatcher`. ``` SynchronizationContext.Current.Post(myAction,null); ``` What is the difference between them and why `SynchronizationContext` should be used?.