Use the OnClosed() method of .base property outside the Window class in WPF C# application

Question

I have created an ICommand that apart from executing some SQL procedures, it checks whether or not the MainWindow UI has been closed while the SQL procedures are executing. In case the MainWindow is closed by the user, the I want the application to simply stop by using the property return;.

My problem is that the ICommand is inside an MVVM model. And this MVVM model is outside the MainWindow (Window class). So, when I try to call the base.OnClosed I get an error that I cannot access it because of its protection level (Window methods are either protected or private).

How my code implementation looks like:

namespace Project
{
    class ClosedClass //I turned it into a class because methods cannot be accessed outside the Window Class
    {
        public bool IsClosed {get; private set;}
        protected override void OnClosed (EventArgs e)
        {
            base.OnClosed(e); //Error: object does not contain a definition for 'OnClosed'
            //(Approach 2) MainWindow.OnClosed(e); //Error: is inaccessible due to its protection level
            
            IsClosed=true;
        }
    }
    
    public class MainWindowViewModel: INotifyPropertyChanged
    {
        public ICommand RunCommand
        {
            get {retun new DelegateCommand<object>(FuncRunCommand);)
        }
        public async void FuncRunCommand(object parameters)
        {
            await Task.Run(() => RunCustomMetod()); //inside this method lies the IsClosed statement
        }
        
        public void RunCustomMetod()
        {
            if(IsClosed) //Error: The name 'IsClosed' does not exist in the current context
            {
                return; //this stops the execution of the RunCustomMetod() if IsClose is true
            }
        }
    }
    public partial class MainWindow : Window
    {
        //... 
    }
}

Based on some research I did for similar questions I found out those two answers:

• https://stackoverflow.com/a/52311178/14456240
• https://stackoverflow.com/a/23014809/14456240

However, my inexperience with C# did not help me to understand how to solve my problem even though the answers were clear. Any suggestions? I appreciate your time and effort in advance.

[UPDATE -- based on the comments]

namespace Project
{
    public class MainWindowViewModel: INotifyPropertyChanged
    {
        
        public bool IsClosed {get; private set;}
        protected override void OnClosed(EventArgs e) //1.Error: MainWindowViewModel.OnClosed(EventArgs)': no suitable method found to override

        {
            MainWindow.OnClosed(e) //2.Error: Inaccessible due to its protection level
            ((MainWindowViewModel)DataContext).IsClosed = true; //3.Error: 'DataContext' does not exist in the current context.
        }

        public ICommand RunCommand
        {
            get {retun new DelegateCommand<object>(FuncRunCommand);)
        }
        public async void FuncRunCommand(object parameters)
        {
            await Task.Run(() => RunCustomMetod()); //inside this method lies the IsClosed statement
        }
        
        public void RunCustomMetod()
        {
            if(IsClosed) //Error: The name 'IsClosed' does not exist in the current context
            {
                return; //this stops the execution of the RunCustomMetod() if IsClose is true
            }
        }
    }
    public partial class MainWindow : Window
    {
        //... 
    }
}

Answer 1

This is MVVM, so you don't want the view model to care about any state of the UI. Also, you never want the view model to depend on methods defined in a view class.
If the view model depends on properties, use data binding to send the value to the view model, but avoid to introduce properties just to observe the view (as this is most of the time a hint for a bad design).

What you obviously really want is to allow the view to cancel the executing command (or more precisely the background thread) based on the UI state or a user interaction.

The recommended approach in such a scenario is to use the simple Task cancellation pattern using a CancellationToken.

When the window closes, you invoke a CancellationTokenSource.Close() method. Generally all Task library API methods support cancellation. Simply chose the appropriate overload that accepts a reference to a Cancellationtoken.

To provide a cancellation mechanism for custom methods, you simply have to pass around a reference to the actual CancellationToken (created by a CancellationTokenSource and call CancellationToken.ThrowIfCancellationRequested() to make the CancellationToken throw an OperationCancelledException in case CancellationTokenSource.Close() was invoked (alternatively poll CancellationToken.IsCancellationRequested):

MainViewModel.cs

public class MainViewModel : INotifyProeprtyChanged
{
  public MainViewModel()
  {
    this.CancellationTokenSource = new CancellationTokenSource();
  }

  private void CancelSql(object obj)
  {
    this.CancellationTokenSource?.Cancel();
  }

  private async void ExecuteSqlAsync(object obj)
  {
    // The complete Task API accepts a CancellationToken to allow cancellation.
    try
    {
      await Task.Run(() => RunCustomMethod(this.CancellationTokenSource.Token), this.CancellationTokenSource.Token);
    }
    catch (OperationCanceledException e)
    {
      // Do some optional cleanup before recovering from the exception

      // Once cancelled, we have to use a new CancellationTokenSource instance. 
      // But first, we have to dispose the old one
      this.CancellationTokenSource.Dispose();
      this.CancellationTokenSource = new CancellationTokenSource();
    }
  }

  private void RunCustomMethod(CancellationToken cancellationToken)
  {
    // Test if operation has already been cancelled.
    // This stops the execution of the current method, if the CancelSqlCommand was executed.
    cancellationToken.ThrowIfCancellationRequested();

    // Continue execution. Periodically call cancellationToken.ThrowIfCancellationRequested()
    // whenever possible to allow cancellation of the current operation.

    // Dummy loop to create a executable example
    while (true)
    {
      // Periodically check if the operation has been cancelled
      cancellationToken.ThrowIfCancellationRequested();
    }
  }

  public ICommand AbortSqlCommand => new DelegateCommand<object>(CancelSql);
  public ICommand ExecuteSqlCommand => new DelegateCommand<object>(ExecuteSqlAsync);
  private CancellationTokenSource CancellationTokenSource { get; set; }
}

SomeWindow.xaml.cs

public partial class SomeWindow : Window
{
  public SomeWindow()
  {
    InitializeComponent();

    this.DataContext = new MainViewModel();
    this.Closing += CancelSqlOperationsOnClosing;
  }

  private void CancelSqlOperationsOnClosing(object sender, CancelEventArgs e)
  {
    if (this.DataContext is MainViewModel viewModel)
    {
      viewModel.AbortSqlCommand.Execute(string.Empty);
    }
  }
}