Why doesn't changing the bound property update the checkbox's visual state during runtime?

I have a simple WPF application with a drop down and a checkbox:

The XAML looks like the following:

<StackPanel>
   <ComboBox ItemsSource="{Binding FileTypes}" SelectedItem="{Binding SelectedFileType, Mode=TwoWay}"/>
   <CheckBox Content="test" IsChecked="{Binding IsChecked}"/>
</StackPanel>

I would like to force the checkbox to go unchecked when I select "Word" from the drop down. I've tried to achieve this by implementing INotifyPropertyChanged in my data context and then subscribing to the PropertyChanged event of the property which represents the selected item from the drop down, SelectedFileType. Here's the code I have so far:

public class MainViewModel : INotifyPropertyChanged
{
   private string m_selectedFileType;
   public List<string> FileTypes { get; set; }
   public bool IsChecked { get; set; }

   public string SelectedFileType
   {
      get => m_selectedFileType;
      set
      {
         m_selectedFileType = value;
         PropertyChanged(this, new PropertyChangedEventArgs((nameof(SelectedFileType))));
      }
   }

   public event PropertyChangedEventHandler PropertyChanged;

   public MainViewModel()
   {

      FileTypes = new List<string>();
      FileTypes.Add("Excel");
      FileTypes.Add("Word");

      PropertyChanged += FileTypeChanged;
      SelectedFileType = "Excel";

      IsChecked = true;
   }

   private void FileTypeChanged(object sender, PropertyChangedEventArgs e)
   {
      if (SelectedFileType == "Word")
      {
         IsChecked = false;
      }
   }
}

Unfortunately, when I run the app and switch from "Excel" to "Word" in the drop down, the check box remains unchanged, so I feel that I am missing something.

I have already tried switching to TwoWay binding and using UpdateSourceTrigger but none of those things have worked.

Why does modifying the SelectedFileType property during runtime not affect the visual state of the checkbox, even though I have clearly set it as a two-way binding in XAML?

EDIT

The relevant documentation does mention the following:

> To detect source changes (applicable to OneWay and TwoWay bindings), the source must implement a suitable property change notification mechanism such as INotifyPropertyChanged.

I'm starting to think that perhaps TwoWay binding and INotifyPropertyChanged sort of go hand in hand...

Your IsCheckedproperty doesn't raise the INotifyPropertyChanged.PropertyChanged event.

Whenever you want to send data from the source property (e.g. IsChecked) to a target property (e.g. CheckBox.IsChecked), you must raise the INotifyPropertyChanged.PropertyChanged. Otherwise the Binding won't know that it has to update the target.

BindingMode.TwoWay only means that data can be send back to the source. This mode also includes BindingMode.OneWay behavior to make it two way. In other words, when the the binding target (e.g. CheckBox) changes the value of a two way binding the target has to raise a change notification (via dependency property) to notify the Binding that it has to update the binding source.
Still the source has to raise a change notification in case it updates the value to trigger the Binding (it's actually the BindingExpression to be more precise).

The binding is passive in that it doesn't actively send data between source and target. The sender (binding source in OneWay and binding source and binding target in TwoWay or binding target in OneWyToSource mode) must always explicitly trigger the binding to transfer data by raising a change notification (by implementing INotifyPropertyChangedand raisePropertyChanged` or by implementing the property as dependency property).

See Microsoft Docs: Data binding overview (WPF .NET).

Furthermore, your current code will update the IsChecked property every time that any property changes. You must filter for the correct property in your PropertyChanegd event handler:

private void FileTypeChanged(object sender, PropertyChangedEventArgs e)
{
  switch (e.PropertyName)
  {
    case nameof(this.IsChecked):
      if (this.SelectedFileType == "Word")
      {
        this.IsChecked = false;
      }
      break;
  }
}

But because you are the the owner of those properties, you don't have to handle the PropertyChanged event. Instead invoke a e.g. OnIsChekedChanged method from the property setter.
You can find a better and recommended INotifyPropertyChanged implementation in the .NET docs: PropertyChanged example.

The improved and fixed version of your code could look as follows:

class MainViewModel : INotifyProeprtyChanged
{
  private bool isChecked;
  public bool IsChecked
  {
    get => this.isChecked;
    set
    {
      this.isChecked = value;
      OnPropertyChanged();
      OnIsCheckedChanged();
    }
  }

  private string selectedFileType;
  public string SelectedFileType
  {
    get => this.selectedFileType;
    set
    {
      bool oldValue = this.IsChecked;
      this.selectedFileType = value;
      OnPropertyChanged();
      OnIsCheckedChanged(oldValue, value);
    }
  }

  protected virtual void OnIsCheckedChanged(bool oldValue, bool newValue)
  {
    if (this.SelectedFileType.Equals("Word", StringComparison.InvariantCultureIgnoreCase)
    {
      this.IsChecked = false;
    }
  }
}

You forgot to notify the view that the IsChecked property has changed.

I took the freedom to modify your code a bit, this should work:

This would be the XAML

<StackPanel>
   <ComboBox ItemsSource="{Binding FileTypes}" SelectedItem="{Binding SelectedFileType}"/>
   <CheckBox Content="test" IsChecked="{Binding IsChecked}"/>
</StackPanel>

and this is where the change will happen:

public class MainViewModel : INotifyPropertyChanged
{ 
    public MainViewModel()
    {
        SelectedFileType = "Excel";
        IsChecked = true;
    }

    public event PropertyChangedEventHandler PropertyChanged;
    // Implement a method to raise property changed calls
    private void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    // Created a new private field and exposed it using a property for code consistency
    // Also used ObservableCollection because it notifies the view when an item is added to the collection
    private ObservableCollection<string> file_types = new ObservableCollection<string>() { "Word", "Excel" };
    public ObservableCollection<string> FileTypes
    {
        get => file_types;
        private set => file_types = value; // You usually don't need to recreate an ObservableCollection, only modify it
    }

    private bool is_checked = false;
    public bool IsChecked
    {
        get => is_checked;
        set
        {
            is_checked = value;
            // Notifiy the view of the change
            OnPropertyChanged(nameof(IsChecked));
        }
    }

    private string m_selectedFileType;
    public string SelectedFileType
    {
        get => m_selectedFileType;
        set
        {
            m_selectedFileType = value;
            OnPropertyChanged(nameof(SelectedFileType));

            // Use the existing binding to the property instead of an event
            if (SelectedFileType == "Word")
            {
                // this will trigger the property setter thus triggering the OnPropertyChanged method
                IsChecked = false; 
            }
        }
    }
}

Edit: I think you have misunderstood how Binding Mode actually works. I found this article to be pretty easy to understand.

TLDR;
Adding any Mode to a binding requires that the elements have a common binding property. For example a Slider and a TextBox. The Slider has its value bound to a property called SliderValue(example) and the TextBox has its Text property bound to the same SliderValue property. The Binding Mode just gives us control over which of these control can change the view value of the other. Notice that they both have a common property they are bound to, which in your case is not true.

Considering this code as our context:

<Slider Name="Slider1" Value="0" SmallChange="1" Maximum="100" ></Slider>

<TextBox Name="txtValue" Text="{Binding Mode=TwoWay, ElementName=Slider1,Path=Value, UpdateSourceTrigger=PropertyChanged}"></TextBox>

OneWay - this will allow the slider to change the value of the text box but not the other way around
OneWayToSource - this will allow the text box to change the value of the slider but not the other way around
Two way - this will allow both components to update each other

Your implementation of a Binding Mode follows none of this.