MVVM бизнес логика и Model

using Common;
using Common.DTOs;
using Common.Entities;
using Common.Interfaces;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
 
namespace Model.Monitor
{
    // Реализация интерфейса. Так как потребители будут использовать
    // Модель ТОЛЬКО через интерфейс, то все XML-комменты к членам
    // должны наследоваться от интерфейса.
 
    // Если Модели нужнообращаться за данными к Сервису, то пусть обращается.
    // Но это должно быть инкапсулированно от Потребителей.
    public partial class MonitorModel : IMonitorModel
    {
        public event EventHandler<MonitorChangedArgs> MonitorChanged;
 
        /// <inheritdoc cref="IMonitorModel.ActivateMonitor(string)"/>
        public void ActivateMonitor(string name)
        {
            if (MonitorsDomain.TryGetValue(name, out var monitor)
                && !monitor.IsActive)
            {
                monitor.IsActive = true;
                MonitorChanged?.Invoke(this, new MonitorChangedArgs(Create(monitor), MonitorChangedEnum.Activate));
            }
        }
 
        /// <inheritdoc cref="IMonitorModel.ChangeColorConfiguration(string)"/>
        public void ChangeColorConfiguration(string name, double colorConfiguration)
        {
            if (MonitorsDomain.TryGetValue(name, out var monitor) &&
                monitor.ColorConfiguration != colorConfiguration)
            {
                monitor.ColorConfiguration = colorConfiguration;
                MonitorChanged?.Invoke(this, new MonitorChangedArgs(Create(monitor), MonitorChangedEnum.Activate));
            }
        }
 
 
        /// <inheritdoc cref="IMonitorModel.DeactivateMonitor(string)"/>
        public void DeactivateMonitor(string name)
        {
            if (MonitorsDomain.TryGetValue(name, out var monitor)
                && monitor.IsActive)
            {
                monitor.IsActive = false;
                MonitorChanged?.Invoke(this, new MonitorChangedArgs(Create(monitor), MonitorChangedEnum.Deactivate));
            }
        }
 
        /// <inheritdoc cref="IMonitorModel.DeleteMonitor(string)"/>
        public void DeleteMonitor(string name)
        {
            MonitorsDomain.Remove(name);
            // TODO: не понятно что делать при удалении
        }
 
        /// <inheritdoc cref="IMonitorModel.GetMonitor(string)"/>
        public MonitorConfigurationDto? GetMonitor(string name)
        {
            if (MonitorsDomain.TryGetValue(name, out var monitor))
            {
                return Create(monitor);
            }
            else
            {
                return null;
            }
        }
 
        /// <inheritdoc cref="IMonitorModel.GetMonitors"/>
        public ReadOnlyCollection<MonitorConfigurationDto> GetMonitors()
            => MonitorsDomain.Values.Select(Create).ToReadOnlyList();
 
        /// <inheritdoc cref="IMonitorModel.GetMonitorNames"/>
        public ReadOnlyCollection<string> GetMonitorNames()
            => MonitorsDomain.Values.Select(monitor => monitor.Name).ToReadOnlyList();
 
 
        /// <inheritdoc cref="IMonitorModel.RefreshMonitors"/>
        public void RefreshMonitors()
        {
            Dictionary<string, MonitorConfigurationDto> monitors = ModelService.LoadMonitors().ToDictionary(mont => mont.Name);
            foreach (var monitor in MonitorsDomain.Values)
            {
                if (!monitors.TryGetValue(monitor.Name, out MonitorConfigurationDto newMonitor))
                {
                    DeleteMonitor(monitor.Name);
                }
                else
                {
                    if (newMonitor.IsActive)
                    {
                        ActivateMonitor(monitor.Name);
                    }
                    else
                    {
                        DeactivateMonitor(monitor.Name);
                    }
 
                    ChangeColorConfiguration(monitor.Name, newMonitor.ColorConfiguration);
 
                    monitors.Remove(monitor.Name);
                }
            }
 
            foreach (var monitor in monitors.Values)
            {
                MonitorsDomain.Add(Create(monitor));
                MonitorChanged?.Invoke(this, new MonitorChangedArgs(monitor, MonitorChangedEnum.Add));
            }
        }
 
    }
}

using System.Collections.Generic;
using Common.DTOs;
 
namespace Model.Monitor
{
 
    public partial class MonitorModel
    {
        internal class ModelService
        {
 
            ///// <summary>
            ///// Создание бизнес сущностей
            ///// Предпологается что сущность будет загружатся из API
            ///// а ее поля из файла
            ///// </summary>
            //private void LoadMonitors()
            //{
            //    MonitorsDomain.Add(new MonitorConfigurationDomainEntity("Monitor 1")
            //    {
            //        ColorConfiguration = 6600,
            //        Height = 1000,
            //        IsActive = true,
            //        Width = 1000
            //    });
            //    MonitorsDomain.Add(new MonitorConfigurationDomainEntity("Monitor 2")
            //    {
            //        ColorConfiguration = 5500,
            //        Height = 2000,
            //        IsActive = true,
            //        Width = 2000
            //    });
            //    MonitorsDomain.Add(new MonitorConfigurationDomainEntity("Monitor 3")
            //    {
            //        ColorConfiguration = 7000,
            //        Height = 3000,
            //        IsActive = false,
            //        Width = 3000
            //    });
            //}
 
            /// <summary>Это может быть и какой-то внешний метод какой-то Службы или Сервиса.
            /// Он ни сего не создаёт сам. Создавать Бизнес Сущности может только Модель.</summary>
            /// <returns>Множество с данными для мониторов. Имена мониторов должны быть уникальными.</returns>
            public static HashSet<MonitorConfigurationDto> LoadMonitors()
            {
                // Здесь чтение из файла и формирование списка.
                // Мониторы должны иметь уникальные имена
                HashSet<MonitorConfigurationDto> monitors = new(MonitorEqualityComparer.Instance);
                monitors.Add(new MonitorConfigurationDto
                    (
                        "Monitor 1",
                        1000,
                        1000,
                        true,
                        6600
                    )
                );
                monitors.Add(new MonitorConfigurationDto
                    (
                        "Monitor 2",
                        2000,
                        2000,
                        true,
                        5500
                    )
                );
                monitors.Add(new MonitorConfigurationDto
                    (
                        "Monitor 3",
                        3000,
                        3000,
                        false,
                        7000
                    )
                );
 
                // Возврат сформированного списка
                return monitors;
            }
        }
 
    }
}

        public void DeleteMonitor(string name)
        {
            // TODO: не понятно что делать при удалении, должно ли быть какое либо уведомление?
            // Конечно должно.
            // Слушатели должны же узнать какой монитор удалён.
            // Слушатель может быть множество: один удалил - остальные должны об этом узнать.
            // Общий принцип: потребители не знают как изменится состояние Модели после вызова метода,
            // поэтому своё состояние они меняют ТОЛЬКО по событие, а не потому, что был вызван метод.
            if (MonitorsDomain.TryGetValue(name, out MonitorConfigurationDomainEntity monitor))
            {
                MonitorsDomain.Remove(name);
                MonitorChanged?.Invoke(this, new MonitorChangedArgs(Create(monitor), MonitorChangedEnum.Delete));
            }

        public void RefreshMonitors()
        {
            Dictionary<string, MonitorConfigurationDto> newMonitors = ModelService.LoadMonitors().ToDictionary(mont => mont.Name);
            foreach (var existingMonitor in MonitorsDomain.Values)
            {
                // Пытаемся получить значение поля Name у сущности из newMonitors
                // Если Name у сущности из MonitorsDomain совпадает с Name из newMonitors
                // То удаляем эту сущность из MonitorsDomain
                // То есть это означает что объект будет пересоздан
                // Иначе меняем значения полей у сущности из MonitorsDomain на значения сущности из newMonitors
                // То есть мы нашли существующий объект в MonitorsDomain и вместо того чтобы пересоздавать его мы его меняем
 
                // TODO: Мне кажется это все довольно странным, почему нам не пересоздать сущность даже если она имеется?
                // TODO: Оптимизация?
                // В данном случае, можно удалить и заново создать.
                // Но в общем случае (по самому смыслу, логике) "удаление + создание"
                // не является эквивалентом обновления состояния.
                // У Бизнес Сущностей может быть гораздо более сложная логика. Сейчас доделаем до рабочей версии,
                // чтобы вы поняли принцип, а потом часть логики модели перенесём в Бизнес Сущности.
                // Мы её реализовали в Основной части Модели, только для того чтобы вам было понятнее.
 
                // TODO: Я так понял для сокращения кода и  большей наглядности добавлены новые методы расширения.
                // Не понял. Что за методы расширения?
 
                if (!newMonitors.TryGetValue(existingMonitor.Name, out MonitorConfigurationDto newMonitor))
                {
                    DeleteMonitor(existingMonitor.Name);
                }

#nullable enable
        private MonitorConfigurationDto? _selectedMonitor;
        public MonitorConfigurationDto? SelectedMonitor
        {
            get => _selectedMonitor;
            set => Set(ref _selectedMonitor, value);
        }
#nullable disable

        public ObservableCollection<MonitorConfigurationDto> Monitors { get; } = new();

        public MainWindowViewModel() 
        {
            BindingOperations.EnableCollectionSynchronization(Monitors, ((ICollection)Monitors).SyncRoot);
        }
        public MainWindowViewModel(IMonitorModel monitorModel, ICurrentTimeModel currentTimeModel, IRandomizerModel randomizerModel)
            : this()
        {

        private readonly IMonitorModel monitorModel;
        private readonly ICurrentTimeModel currentTimeModel;
        private readonly IRandomizerModel randomizerModel;
 
        private string _currentTime = "12:00";
        private bool _randomizerState;

        public bool RandomizerState
        {
            get => _randomizerState;
            set
            {
                if (Set(ref _randomizerState, value))
                {
                    if (value)
                    {
                        randomizerModel.Start(monitorModel);
                    }
                    else
                    {
                        randomizerModel.Stop();
                    }
                }
            }
        }

        public bool RandomizerState
        {
            get => _randomizerState;
            set => Set(ref _randomizerState, value);
        }

        protected override void OnPropertyChanged(in string propertyName, in object oldValue, in object newValue)
        {
            base.OnPropertyChanged(propertyName, oldValue, newValue);
 
            if (propertyName == nameof(RandomizerState))
            {
                if ((bool)newValue)
                {
                    randomizerModel.Start(monitorModel);
                }
                else
                {
                    randomizerModel.Stop();
                }
            }
        }

            monitorModel.MonitorChanged += (_, args) =>
            {
                // TODO: Стоит ли каждый раз пересоздавать коллекцию или же нужно пересоздавать/менять конкретный монитор?
                Monitors = new ObservableCollection<MonitorConfigurationDto>(monitorModel.GetMonitors());
 
                // Не стоит. Это делает бессмысленным использвоание ObservableCollection.
                // Monitors лучше сделать "Только для чтения".
                // Надо найти изменённый Монитор и заменить только его.
                // Для этого есть метод в Библиотеке Common.
                // Так же нужно по разному обрабатывать разные действия события:
                switch (args.Action)
                {
                    case MonitorChangedEnum.Add:
                        Monitors.Add(args.Monitor);
                        break;
                    case MonitorChangedEnum.Delete:
                        Monitors.RemoveFirst(montr => montr.Name == args.Monitor.Name);
                        break;
                    case MonitorChangedEnum.Activate:
                    case MonitorChangedEnum.ChangeColor:
                    case MonitorChangedEnum.Deactivate:
                        Monitors.Replace(montr => montr.Name == args.Monitor.Name, args.Monitor);
                        break;
                    default:
                        throw new ArgumentException("Чё-то не то", "args.Action");
                }

            else if (propertyName == nameof(SelectedMonitorName))
            {
                string name = (string)newValue;
                if (string.IsNullOrWhiteSpace(name))
                {
                    SelectedMonitor = null;
                }
                else
                {
                    SelectedMonitor = monitorModel.GetMonitor(name);
                }
            }

            monitorModel.MonitorChanged += (_, args) =>
            {
                switch (args.Action)
                {
                    case MonitorChangedEnum.Add:
                        Monitors.Add(args.Monitor.Name);
                        break;
                    case MonitorChangedEnum.Delete:
                        Monitors.RemoveFirst(monitorName => monitorName == args.Monitor.Name);
                        break;
                    case MonitorChangedEnum.Activate:
                    case MonitorChangedEnum.ChangeColor:
                    case MonitorChangedEnum.Deactivate:
                        if (!string.IsNullOrEmpty(SelectedMonitor?.Name) && SelectedMonitor.Name == args.Monitor.Name)
                        {
                            SelectedMonitor = args.Monitor;
                        }
                        break;
                    default:
                        throw new ArgumentException("Чё-то не то", "args.Action");
                }
            };

            else if (propertyName == nameof(SelectedMonitorName))
            {
                string name = (string)newValue;
                SelectedMonitor = monitorModel.GetMonitor(name);
            }