WPF - Update bound property from non-UI thread

Question

I cannot understand if it is mandatory to use Dispatcher to notify UI thread that a bound property has been updated by a non-UI thread.
Starting from a basic example, why is the following code not throwing the famous (I remember struggling on this in past coding experiences) The calling thread cannot access this object because a different thread owns it exception?

private int _myBoundProperty;
public int MyBoundProperty { get { return _myBoundProperty; } set { _myBoundProperty = value; OnPropertyChanged(); } }
private void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
public void Test()
{
    new System.Threading.Thread(() =>
    {
        try
        {
            MyBoundProperty += DateTime.Now.Second;
        }
        catch(Exception ex)
        {
        }
    }).Start();
}

<TextBlock Text="{Binding MyBoundProperty"/>

I saw some posts on this topic, but they seem to me quite confusing:

• someone stating Dispatcher is required for collections but not for single variables: so why this other example still not throwing exception?

private ObservableCollection<int> _myBoundPropertyCollection;
public ObservableCollection<int> MyBoundPropertyCollection { get { return _myBoundPropertyCollection; } set { _myBoundPropertyCollection = value; OnPropertyChanged(); } }
private void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
public void TestCollection()
{
    new System.Threading.Thread(() =>
    {
        try
        {
            //MyBoundPropertyCollection = new ObservableCollection() { 0 }; //even so not throwing
            MyBoundPropertyCollection[0] += DateTime.Now.Second;
        }
        catch(Exception ex)
        {
        }
    }).Start();
}

<TextBlock Text="{Binding MyBoundPropertyCollection[0]"/>

• someone stating it was something required by previous .NET versions: so now can we removed those Dispatcher calls (I am using .NET Framework 4.7)?
• someone stating it is a good practice to use Dispatcher even if your code does not throw exception: seems like an act of faith...

Answer 1

Your first example isn't modifying any UI thread related DispatcherObject from a forbidden thread. The binding engine automatically marshals the INotifyPropertyChanged.PropertChanged event or the invocation of it's registered event handlers to the UI thread. This means the UI's Binding.Target, which is a DispatcherObject, is always correctly updated on the UI thread.

// Safe, because PropertyChanged will always be raised on the UI thread
MyBoundProperty = DateTime.Now; 

This doesn't apply for INotifyCollectionChanged.CollectionChanged. A collection changed from a background thread must marshal the modification of the collection manually either by invoking the Dispatcher that is registered for the thread or by capturing the SynchronizationContext.Current of the owning or calling thread to be able to post the critical operation back to the proper context (thread).

// Assuming that this is the proper thread of the DispatcherObject, 
// that binds to MyBoundPropertyCollection
SynchronizationContext capturedSynchronizationContext = SynchronizationContext.Current;

Task.Run(() =>
  {
    // Will throw a cross-thread exception
    MyBoundPropertyCollection.Add(item); 

    // Safe
    Dispatcher.Invoke(() => MyBoundPropertyCollection.Add(item)); 

    // Safe
    capturedSynchronizationContext.Post(state => MyBoundPropertyCollection.Add(item), null); 
  });

Since your second example is equal to the first example, it won't throw for the very same reason. You are not modifying the collection e.g. Add/Insert/Move/Remove, but an item contained in this collection:

Task.Run(() => MyBoundPropertyCollection[0] = DateTime.Now);

is equal to

Task.Run(() =>
  {
    var myBoundProperty = MyBoundPropertyCollection[0];

    // Safe, because PropertyChanged will always be raised on the UI thread
    myBoundProperty = DateTime.Now; 
  });

Every object that derives from DispatcherObjecte.g. TextBox is associated with the thread it was created on (thread affinity) by mapping it to the thread's Dispatcher. Only this thread is allowed to modify the DispatcherObject. Other threads have to use either the associated Dispatcher or the SynchronizationContext of the DispatcherObject owner thread.

If you want to pass a DispatcherObject from one thread to another e.g., pass a Brush to the UI thread, then this is only possible when the DispatcherObject derives from Freezable. You'd call Freezable.Freeze, which lifts the thread affinity i.e Dispatcher affinity and allows to pass the instance to some other thread.