MVVM - Wyświetlanie messagebox i zamykanie okna z potwierdzeniem

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections.ObjectModel;
using System.Windows.Input;
using SimpleWindow.Commands;
using SimpleWindow.Helpers;
using SimpleWindow.Interfaces;

namespace SimpleWindow.Viewmodels
{
    public class MainWindowVM : ViewModelBase
    {
        public ICommand Close
        {
            get { return new RelayCommand(() => this.Closing?.Invoke()); }
        }

        public delegate void ClosingEventHandler();
        public event ClosingEventHandler Closing;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Collections.ObjectModel;
using SimpleWindow.Viewmodels;

namespace SimpleWindow
{
    public partial class MainWindow : Window
    {
        private MainWindowVM viewmodel;

        public MainWindow()
        {
            InitializeComponent();

            this.viewmodel = new MainWindowVM();
            this.viewmodel.Closing += () => this.Close();
            this.DataContext = this.viewmodel;

            this.Closing += (sender, args) =>
            {
                var result = MessageBox.Show("Can I close?", "", MessageBoxButton.YesNo, MessageBoxImage.Question);
                if (result == MessageBoxResult.No) args.Cancel = true;
            };
        }

    }
}

<Window x:Class="SimpleWindow.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
        xmlns:dp="clr-namespace:SimpleWindow.DPs"
        xmlns:local="clr-namespace:SimpleWindow"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525" 
        WindowStartupLocation="CenterScreen">
    <Button Content="Close me!"
            Command="{Binding Close}"/>
</Window>

using System;
using System.Linq;
using System.Reflection;
using System.Windows;
using System.Windows.Input;
using System.Windows.Interactivity;

public sealed class InvokeDelegateCommandAction : TriggerAction<DependencyObject>
{
    /// <summary>
    ///
    /// </summary>
    public static readonly DependencyProperty CommandParameterProperty =
        DependencyProperty.Register("CommandParameter", typeof(object), typeof(InvokeDelegateCommandAction), null);

    /// <summary>
    ///
    /// </summary>
    public static readonly DependencyProperty CommandProperty = DependencyProperty.Register(
        "Command",
        typeof(ICommand),
        typeof(InvokeDelegateCommandAction),
        null);

    /// <summary>
    ///
    /// </summary>
    public static readonly DependencyProperty InvokeParameterProperty =
        DependencyProperty.Register("InvokeParameter", typeof(object), typeof(InvokeDelegateCommandAction), null);

    private string commandName;

    /// <summary>
    ///
    /// </summary>
    public object InvokeParameter
    {
        get
        {
            return this.GetValue(InvokeParameterProperty);
        }

        set
        {
            this.SetValue(InvokeParameterProperty, value);
        }
    }

    /// <summary>
    ///
    /// </summary>
    public ICommand Command
    {
        get
        {
            return (ICommand)this.GetValue(CommandProperty);
        }

        set
        {
            this.SetValue(CommandProperty, value);
        }
    }

    /// <summary>
    ///
    /// </summary>
    public string CommandName
    {
        get
        {
            return this.commandName;
        }

        set
        {
            if (this.CommandName != value)
            {
                this.commandName = value;
            }
        }
    }

    /// <summary>
    ///
    /// </summary>
    public object CommandParameter
    {
        get
        {
            return this.GetValue(CommandParameterProperty);
        }

        set
        {
            this.SetValue(CommandParameterProperty, value);
        }
    }

    /// <summary>
    ///
    /// </summary>
    /// <param name="parameter"></param>
    protected override void Invoke(object parameter)
    {
        this.InvokeParameter = parameter;

        if (this.AssociatedObject != null)
        {
            ICommand command = this.ResolveCommand();
            if ((command != null) && command.CanExecute(this.CommandParameter))
            {
                command.Execute(this.CommandParameter);
            }
        }
    }

    private ICommand ResolveCommand()
    {
        ICommand command = null;
        if (this.Command != null)
        {
            return this.Command;
        }
        var frameworkElement = this.AssociatedObject as FrameworkElement;
        if (frameworkElement != null)
        {
            object dataContext = frameworkElement.DataContext;
            if (dataContext != null)
            {
                PropertyInfo commandPropertyInfo =
                    dataContext.GetType()
                        .GetProperties(BindingFlags.Public | BindingFlags.Instance)
                        .FirstOrDefault(
                            p =>
                                typeof(ICommand).IsAssignableFrom(p.PropertyType)
                                && string.Equals(p.Name, this.CommandName, StringComparison.Ordinal));

                if (commandPropertyInfo != null)
                {
                    command = (ICommand)commandPropertyInfo.GetValue(dataContext, null);
                }
            }
        }

        return command;
    }
}

xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

<i:Interaction.Triggers>
    <i:EventTrigger EventName="Closing">
        <local:InvokeDelegateCommandAction Command="{Binding WindowClosingCommand, Mode=OneWay, UpdateSourceTrigger=PropertyChanged}" CommandParameter="{Binding RelativeSource={RelativeSource Self}, Path=InvokeParameter}" />
    </i:EventTrigger>
    <i:EventTrigger EventName="Closed">
        <i:InvokeCommandAction Command="{Binding WindowClosedCommand, Mode=OneWay, UpdateSourceTrigger=PropertyChanged}" />
    </i:EventTrigger>
</i:Interaction.Triggers>

public ICommand WindowClosedCommand
{
    get
    {
        return new DelegateCommand(this.Dispose, () => true);
    }
}

public ICommand WindowClosingCommand
{
    get
    {
        return new DelegateCommand<CancelEventArgs>(
            e =>
            {
                var result = this.dialogService.ShowMessageBox(
                    this,
                    "Do you want to close this window",
                    "Question...",
                    MessageBoxButton.YesNo);
                e.Cancel = result != MessageBoxResult.Yes;
            });
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Collections.ObjectModel;
using SimpleWindow.Viewmodels;

namespace SimpleWindow
{
    public partial class MainWindow : Window
    {
        private MainWindowVM viewmodel;

        public MainWindow()
        {
            InitializeComponent();

            this.viewmodel = new MainWindowVM();

            this.viewmodel.ShowMessageWindow += (message) => MessageBox.Show(message);

            this.DataContext = this.viewmodel;
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections.ObjectModel;
using System.Windows.Input;
using SimpleWindow.Commands;
using SimpleWindow.Helpers;
using SimpleWindow.Interfaces;

namespace SimpleWindow.Viewmodels
{
    public class MainWindowVM : ViewModelBase
    {
        public ICommand ShowMessage
        {
            get { return new RelayCommand(() => this.ShowMessageWindow?.Invoke("Hello world!")); }
        }

        public delegate void ShowMessageEventHandler(string message);
        public event ShowMessageEventHandler ShowMessageWindow;
    }
}