Где лучше в MVVM реализовать дополнительную логику?

IAsyncResult asyncResult = sqlCmd.BeginExecuteNonQuery();
while (!asyncResult.IsCompleted)  //UI thread needs to Wait for Async SQL command to return
{
      System.Threading.Thread.Sleep(10);  // ИЛИ Do Command Execution 
      Application.DoEvents();  //to make the UI responsive !!!
}

private SynchronizationContext _viewContext;
 
public SynchronizationContext ViewContext
{
    get => _viewContext;
    set => Set(ref _viewContext, value); // Тут была логика, потому такая сложная запись
}
 
private async Task LoadVMDataAsync()
{
    try
    {
        List<HBSpecificationGroup> groups = await _mainDA.HBSpecificationGroupDA.GetHBSpecificationGroupsAsync(Branch);
        // Синхронизируем контекст
        ViewContext.Send(_ =>
        {
            // Что-то делаем в нужном контексте
            if (Groups.Count > 0)
                Groups.Clear();
 
            if (groups.Count > 0)
                groups.ForEach(g => Groups.Add(g));
            // Дёргаем событие
            GroupsLoaded?.Invoke(this, EventArgs.Empty);
        }, null);
    }
    catch (Exception ex)
    {
        if (ex.InnerException != null)
        {
 
        }
 
        _windowService.ShowErrorMessage(ex.Message, "Ошибка");
    }
}

public partial class HBSpecificationGroupWindow : Window
{
    private CollectionViewSource _sourceGroups;
    private ListCollectionView _viewGroups;
 
    public HBSpecificationGroupWindow()
    {
        InitializeComponent();
    }
 
    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        // Получаем экземпляр VM из сервиса
        IHBSpecificationGroupWindowVM vm = (IHBSpecificationGroupWindowVM)DataContext;
 
        _sourceGroups = (CollectionViewSource)Resources["GroupsSorted"];
        _viewGroups = (ListCollectionView)_sourceGroups.View;
        // Подписываемся на событие
        vm.GroupsLoaded += OnGroupsLoaded;
        // Получаем контекст окна через который работаем с другого потока
        vm.ViewContext = SynchronizationContext.Current;
    }
 
    private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
    {
        IHBSpecificationGroupWindowVM vm = (IHBSpecificationGroupWindowVM)DataContext;
        // Отписываемся от события
        vm.GroupsLoaded -= OnGroupsLoaded;
    }
    // Что-то делаем по событию
    private void OnGroupsLoaded(object sender, System.EventArgs e)
    {
        if (_viewGroups.Count > 0)
            _ = _sourceGroups.View.MoveCurrentToFirst();
    }
}

using Simplified;
using System.Windows;
using System.Windows.Threading;
 
namespace CFTopics2025.CF.CanExcuteTest
{
    public partial class CanExecuteTestWindow : Window
    {
        private readonly CanExecuteTestVM vm;
        private readonly DispatcherTimer timer;
        public CanExecuteTestWindow()
        {
            InitializeComponent();
            vm = (CanExecuteTestVM)DataContext;
            timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(1);
            timer.Tick += delegate
            {
                vm.IsBusy = !vm.IsBusy;
            };
            timer.Start();
        }
    }
 
    public class CanExecuteTestVM : BaseInpc
    {
        private bool isBusy;
        private RelayCommand? _simpleCommand;
        private RelayCommand? _raiseCommand;
 
        public bool IsBusy { get => isBusy; set { Set(ref isBusy, value); RaiseCommand.RaiseCanExecuteChanged();} }
 
        public RelayCommand SimpleCommand => _simpleCommand ??= new RelayCommand(() => { }, () => IsBusy);
        public RelayCommand RaiseCommand => _raiseCommand ??= new RelayCommand(() => { }, () => IsBusy);
    }
}

public class MyViewModel : ObservableObject // Assuming ObservableObject provides PropertyChanged notification
{
    private string _userName;
    public string UserName
    {
        get => _userName;
        set
        {
            SetProperty(ref _userName, value); // Raises PropertyChanged
            MyCommand.NotifyCanExecuteChanged(); // Notify command to re-evaluate CanExecute
        }
    }
 
    public RelayCommand MyCommand { get; }
 
    public MyViewModel()
    {
        MyCommand = new RelayCommand(ExecuteMyCommand, CanExecuteMyCommand);
    }
 
    private void ExecuteMyCommand()
    {
        // Command logic here
    }
 
    private bool CanExecuteMyCommand()
    {
        return !string.IsNullOrWhiteSpace(UserName);
    }
}

using Simplified;
using System.Windows;
 
namespace CFTopics2025.CF.CanExcuteTest
{
    public partial class AuthorizationWindow : Window
    {
        public AuthorizationWindow()
        {
            InitializeComponent();
        }
    }
 
    public class AuthorizationViewModel : BaseInpc
    {
        private readonly AuthorizationModel model;
        private RelayCommand<AuthorizeData>? _authorize;
        private WorkViewModel? _work;
        private Exception? _authorizationException;
        public AuthorizationViewModel()
            : this(new AuthorizationModel())
        { }
 
        public AuthorizationViewModel(AuthorizationModel model)
        {
            this.model = model;
        }
 
        public WorkViewModel? Work { get => _work; set => Set(ref _work, value); }
        public Exception? AuthorizationException { get => _authorizationException; set => Set(ref _authorizationException, value); }
 
 
        public RelayCommand<AuthorizeData> Authorize
            => _authorize ??= new RelayCommand<AuthorizeData>
            (
                data =>
                {
                    try
                    {
                        WorkModel? work = model.Authorize(data.Name, data.Password);
                        if(work is null)
                            throw new NullReferenceException("Авторизация не удачна");
                        Work = new WorkViewModel(work);
                    }
                    catch (Exception ex)
                    {
                        Work = null;
                        AuthorizationException = ex;
                    }
                },
                data => !string.IsNullOrWhiteSpace(data.Name));
 
    }
 
 
 
    public class WorkViewModel
    {
        private readonly WorkModel model;
 
        public WorkViewModel(WorkModel model)
        {
            this.model = model;
        }
    }
 
    public class WorkModel
    {
    }
 
    public class AuthorizationModel
    {
        public WorkModel? Authorize(string? name, string? password)
        {
            ArgumentException.ThrowIfNullOrWhiteSpace(name);
            ArgumentNullException.ThrowIfNull(password);
            return new WorkModel();
        }
    }
 
    public class AuthorizeData
    {
        public string? Name { get; set; }
        public string? Password { get; set; }
    }
 
}