Архитектура MVVM в многооконном приложении

  public abstract class NotificationObject : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
 
        protected virtual void NotifyPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
 
        protected void SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
        {
            if (!EqualityComparer<T>.Default.Equals(field, value))
            {
                field = value;
                NotifyPropertyChanged(propertyName);
            }
        }
    }

  public class RelayCommand : ICommand
    {
        Action _targetExecuteMethod;
        Func<bool> _targetCanExecuteMethod;
 
        public RelayCommand(Action executeMethod)
        {
            _targetExecuteMethod = executeMethod;
        }
 
        public RelayCommand(Action executeMethod, Func<bool> canExecuteMethod)
        {
            _targetExecuteMethod = executeMethod;
            _targetCanExecuteMethod = canExecuteMethod;
        }
 
        public void RaiseCanExecuteChanged()
        {
            CanExecuteChanged(this, EventArgs.Empty);
        }
        #region ICommand Members
 
        bool ICommand.CanExecute(object parameter)
        {
            if (_targetCanExecuteMethod != null)
            {
                return _targetCanExecuteMethod();
            }
            if (_targetExecuteMethod != null)
            {
                return true;
            }
            return false;
        }
 
        // Beware - should use weak references if command instance lifetime is longer than lifetime
        // of UI objects that get hooked up to command
        // Prism commands solve this in their implementation
        public event EventHandler CanExecuteChanged = delegate { };
 
        void ICommand.Execute(object parameter)
        {
            if (_targetExecuteMethod != null)
            {
                _targetExecuteMethod();
            }
        }
        #endregion
    }
 
    public class RelayCommand<T> : ICommand
    {
        Action<T> _targetExecuteMethod;
        Func<T, bool> _targetCanExecuteMethod;
 
        public RelayCommand(Action<T> executeMethod)
        {
            _targetExecuteMethod = executeMethod;
        }
 
        public RelayCommand(Action<T> executeMethod, Func<T, bool> canExecuteMethod)
        {
            _targetExecuteMethod = executeMethod;
            _targetCanExecuteMethod = canExecuteMethod;
        }
 
        public void RaiseCanExecuteChanged()
        {
            CanExecuteChanged(this, EventArgs.Empty);
        }
        #region ICommand Members
 
        bool ICommand.CanExecute(object parameter)
        {
            if (_targetCanExecuteMethod != null)
            {
                T tparm = (T)parameter;
                return _targetCanExecuteMethod(tparm);
            }
            if (_targetExecuteMethod != null)
            {
                return true;
            }
            return false;
        }
 
        // Beware - should use weak references if command instance lifetime is longer than lifetime of 
        // UI objects that get hooked up to command
        // Prism commands solve this in their implementation
        public event EventHandler CanExecuteChanged = delegate { };
 
        void ICommand.Execute(object parameter)
        {
            if (_targetExecuteMethod != null)
            {
                _targetExecuteMethod((T)parameter);
            }
        }
        #endregion
    }

 public class MainWindowViewModel : NotificationObject
    {
        SecondWindow rg; 
 
        /// <summary>
        /// Комманда для кнопки открывающей второе вью
        /// </summary>
        //private ICommand _toggleSecondViewCommand;
        //public ICommand ToggleSecondViewCommand
        //{
        //    get
        //    {
        //        return _toggleSecondViewCommand;
        //    }
 
        //    private set { }
        //}
 
        /// <summary>
        /// Надпись на кнопке
        /// </summary>
        private string _buttonContent;
        public string ButtonContent
        {
            get => _buttonContent;
            set
            {
                _buttonContent = value;
                NotifyPropertyChanged("ButtonContent");
            }
        }
 
        /// <summary>
        /// Флаг 
        /// </summary>
        private bool _IsRunning;
        public bool IsRunning
        {
            get => _IsRunning;
            set
            {
                _IsRunning = value;
                //обновление кнопки
                StartStopCommand.RaiseCanExecuteChanged();
            }
        }
 
 
        /// <summary>
        /// Кнопка запуска и останова
        /// </summary>
        private RelayCommand _StartStopCommand;
        public RelayCommand StartStopCommand
        {
            // get {return }
            get => _StartStopCommand = _StartStopCommand ?? new RelayCommand(ToggleSecondViewExecute, CanStartStop);
        }
 
        /// <summary>
        ///.ctor 
        /// </summary>
        public MainWindowViewModel()
        {
            //InitializeCommands();
        }
 
        /// <summary>
        /// Start/Stop flag
        /// </summary>
        /// <returns></returns>
        private bool CanStartStop()
        {
            if (IsRunning)
            {
                ButtonContent = "Стоп";
            }
            else
            {
                ButtonContent = "Старт";
            }
 
            return true;
        }
 
 
        private void ToggleSecondViewExecute()
        {
            Boolean windowOpened = false;
 
            if (IsRunning && rg != null)
            {
                IsRunning = false;
            }
            
            else
            {
                if (!windowOpened)
                {
 
                    windowOpened = true;
                    IsRunning = true;
                    rg = new SecondWindow();
                    rg.Show();
                    Debug.WriteLine($"IsRunning = {IsRunning} ButtonContent = {ButtonContent}");
                }
             }
        }
 
        // Deprecated
        //private void InitializeCommands()
        //{
        //    _toggleSecondViewCommand = new RelayCommand(ToggleSecondViewExecute);
        //}
    }

/*
  In App.xaml:
  <Application.Resources>
      <vm:ViewModelLocator xmlns:vm="clr-namespace:WpfMvvm_OpeningTheWindows"
                           x:Key="Locator" />
  </Application.Resources>
  
  In the View:
  DataContext="{Binding Source={StaticResource Locator}, Path=ViewModelName}"
 
  You can also use Blend to do all this with the tool's support.
  See http://www.galasoft.ch/mvvm
*/
 
using System;
using CommonServiceLocator;
using GalaSoft.MvvmLight;
using GalaSoft.MvvmLight.Ioc;
using WpfMvvm_OpeningTheWindows.Views;
 
namespace WpfMvvm_OpeningTheWindows.ViewModels
{
    /// <summary>
    /// This class contains static references to all the view models in the
    /// application and provides an entry point for the bindings.
    /// </summary>
    public class ViewModelLocator
    {
        private MainViewModel _designerMainVm;
 
        /// <summary>
        /// Initializes a new instance of the ViewModelLocator class.
        /// </summary>
        public ViewModelLocator()
        {
            if (ViewModelBase.IsInDesignModeStatic)
            {
                return;
            }
 
            ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);
 
            SimpleIoc.Default.Register<IDialogManager>(() =>
            {
                var dialogManager = new DialogManager();
                dialogManager.RegisterWindow<SecondViewModel, SecondWindow>();
                return dialogManager;
            });
 
            SimpleIoc.Default.Register<MainViewModel>();
        }
 
        public MainViewModel Main
        {
            get
            {
                return !ViewModelBase.IsInDesignModeStatic ?
                    ServiceLocator.Current.GetInstance<MainViewModel>() :
                    _designerMainVm ?? (_designerMainVm = new MainViewModel(new DialogManager()));
            }
        }
 
        public static void Cleanup()
        {
            // TODO Clear the ViewModels
        }
    }
}