Технология связки в WPF

И так, давайте по порядку...

DataContext и ItemsSource

Вы задаете this.Table.ItemsSource = source;, хорошо, но что если у вас будет 10, 20, 30 контролов? У вас будет портянка кода с указанием ItemsSource? Также вы должны стремится к отделению View (своего XAML) от ViewModel (вашего кода) и в таком случае указание ItemSource полностью должно быть реализовано в View части приложения. Для установки ItemSource из XAML нам надо указать соответствующий DataContext. Давайте сделаем это:

• Вместо this.Table.ItemsSource = source; мы пишем DataContext = this;. this в данном случае, это MainWindow, но лучше создать отдельный класс (прим: MainViewModel) и его уже тут использовать.
• Коллекцию source переделываем в свойство и делаем публичным. - public List<Sensor> source { get; set; } = .... Если вы будете добавлять/удалять объекты из коллекции, то стоит использовать ObservableCollection<T>.
• Убираем Name="Table" в XAML. Отвыкайте от работы с контролами через код, привязки ваше все!
• Задаем DataGrid нужный ItemSource - ItemsSource="{Binding source}"

Все, теперь у вас более менее правильная привязка с которой мы можем работать дальше.

INotifyPropertyChanged

Если мы привязали какое то свойство и меняем его через код, то для обновления View части нам необходимо реализовать INotifyPropertyChanged:

• Создадим класс, назовем его к примеру BaseVM.
• Наследуем его от INotifyPropertyChanged.

• Реализовываем самым простейшим способом:

  public class BaseVM : INotifyPropertyChanged
  {
      public event PropertyChangedEventHandler PropertyChanged;
      public void OnPropertyChanged([CallerMemberName]string prop = "")
      {
          PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(prop));
      }
  }

• Наследуем от созданного нами класса тот класс, где содержатся изменяемые свойства (public sealed class Sensor : BaseVM).

• В Set нужного свойства добавляем вызов INPC:

  private bool isActivated;
  public bool IsActivated
  {
      get => isActivated;
      set
      {
          isActivated = value;
          OnPropertyChanged();
      }
  }

Переносим логику

1. Вашу старую логику public bool IsActivated => Condition == 0; мы переносим в свойство Condition (p.s. SelectedIndex это int):

   private int condition;
   public int Condition {
       get => condition;
       set
       {
           condition = value;
           IsActivated = value == 0;
       }
   }

   Скорей всего не будет обновляться свойство. Дописываем в XAML UpdateSourceTrigger в привязке ({Binding Path=Condition, UpdateSourceTrigger=PropertyChanged}).

   Все, теперь нам полностью не нужен ComboBox_SelectionChanged, отписываемся от него.

2. Цвет строки. Любые изменения в UI - это View часть, туда и стоит перенести. Реализуется это довольно легко, путем написания триггера. Внутри DataGrid пишем:

   <DataGrid.RowStyle>
       <Style TargetType="DataGridRow">
           <Style.Triggers>
               <DataTrigger Binding="{Binding IsActivated}" Value="True">
                   <Setter Property="Background" Value="White"/>
               </DataTrigger>
               <DataTrigger Binding="{Binding IsActivated}" Value="False">
                   <Setter Property="Background" Value="LightCoral"/>
               </DataTrigger>
           </Style.Triggers>
       </Style>
   </DataGrid.RowStyle>

   Ну и убираем соответственно Table_LoadingRow.

Все, теперь ваше приложение имеет правильную привязку, без лишних событий и все по своим местам.

реализовать данное приложение, как оно есть, по шаблону MVVM

Собственно почему бы и нет.
Для начала Вам стоит понимать, что такое MVVM подход и для чего он. Я особо рассказывать про его тонкости не буду, главное поймите то, что MVVM - это разделение логики приложения на 3 слоя, которые не связаны друг с другом почти не чем.

• Model - источник данных. В вашем случае это могут быть сенсоры, которые например берутся из базы или от куда либо еще.
• View - UI нашего приложения. В вашем случае это просто MainWindow.
• ViewModel - некий связующий слой, который работает с Model и предоставляет для View публичные свойства, к которым та в последующем привязывается.

Теперь давайте перепишем ваше приложение (имеем уже те правки, что выше).

Основное:

1. Создадим 3 папки, Models, ViewModels, Views (для удобства и лучшего понимания).
2. В Views перекидываем MainWindows целиком. После перекидывания изменяем в .cs и .xaml namespace (добавляем .Views (Sample.Views..).
3. В ViewModels переносим ранее созданный BaseVM (с заменой namespace).
4. В ViewModels создаем главный класс MainViewModel.
5. Теперь мы можем соединить все. Заходим в App.xaml и удаляем там StartupUri="MainWindow.xaml".

6. Заходим в App.xaml.cs и переписываем событие OnStartup, делая что то вроде этого:

   protected override void OnStartup(StartupEventArgs e)
   {
       base.OnStartup(e);
       new MainWindow() { DataContext = new MainViewModel() }.Show();
   }

   Так мы задали нужный нам DataContext и сами отображаем окно.

7. Удаляем из MainWindow.xaml.cs указанный нами ранее DataContext.

8. В местах где будет ругаться на namespace - дописываем нужный и запускаем проект. Должно успешно отобразится окно с дизайном, но без данных.

Убираем лишнее из View слоя:

1. Убираем все имена из XAML, они нам не к чему, их стоит использовать лишь в стилях, каких то триггерах или в чем то еще, где работа чисто на XAML.

2. Для удобства добавляем к Window (в XAML) следующее:

   xmlns:vm="clr-namespace:Sample.ViewModels"
   d:DataContext="{d:DesignInstance {x:Type vm:MainViewModel}}"

   Это позволит дизайнеру знать, какой DataContext сейчас установлен и он будет подсказывать нам об ошибках и предлагать свойства.

3. Убираем все Path= (вкусовщина), я считаю их лишним мусором.

4. Класс Sensor... Ну смотрите, это по сути источник данных и если сенсоры будут где то в базе или в другом месте, то стоит создать для них Model, где вы пропишете всю логику взаимодействия, пока же у вас это простой List<>, который спокойно можно уместить в VM слое. И по этому Переименовываем его в SensorViewModel, переносим в нужную папку, меняем namespace.

5. В MainViewModel переносим инициализацию наших сенсоров в созданное публичное свойство коллекции:

   class MainViewModel
   {
       public ObservableCollection<SensorViewModel> Sensors { get; }
       public MainViewModel()
       {
           Sensors = new ObservableCollection<SensorViewModel>()
           {
               new SensorViewModel("Дверь в гостиную", 0, 1),
               new SensorViewModel("Дверь в кухню", 1, 0),
               new SensorViewModel("Входная дверь", 0, 1),
               new SensorViewModel("Правое окно балкона", 1, 0),
               new SensorViewModel("Левое окно балкона", 0, 1),
               new SensorViewModel("Окно в гостиной", 0, 2)
           };
       }
   }

6. Привязываем DataGrid в XAML к этой коллекции (ItemsSource="{Binding Sensors}").

Все, теперь ваше приложение разделено на слои. В XAML окна мы не связаны какими либо событиями с кодом, в MainWindow.xaml.cs у нас только инициализация контролов, а в MainViewModel у нас нету не намека на контролы из View слоя, ибо идет работа с данными напрямую. Вам же остается доделать все под себя, сделать Model слой (если нужен будет) и др. мелочи.