基于MVVM模式，如何在应用关闭时删除日志文件？

核心疑问解答 #

直接将命令绑定到Closing/Closed事件不违背MVVM模式——MVVM的核心是View与ViewModel的关注点分离，只要删除日志的业务逻辑在ViewModel中实现，View仅负责将事件转发到命令，就符合模式要求。编译错误是因为WPF原生事件无法直接绑定ICommand类型，需要通过事件触发器或附加属性实现转发。

适配VS2019的可行方案 #

方案1：使用Microsoft.Xaml.Behaviors.Wpf（推荐，代码量少） #

旧方案失效多是因为依赖了已废弃的System.Windows.Interactivity包，VS2019中需改用官方维护的Microsoft.Xaml.Behaviors.Wpf：

1. 通过NuGet安装包：Microsoft.Xaml.Behaviors.Wpf
2. 在View的XAML中添加命名空间：

   xmlns:i="http://schemas.microsoft.com/xaml/behaviors"
   

3. 给Window绑定事件到ViewModel命令：

   <Window x:Class="YourApp.MainWindow"
           xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
           xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
           xmlns:i="http://schemas.microsoft.com/xaml/behaviors"
           xmlns:vm="clr-namespace:YourApp.ViewModels">
       <Window.DataContext>
           <vm:MainViewModel />
       </Window.DataContext>
       <i:Interaction.Behaviors>
           <!-- 关闭前事件，可用于确认或取消关闭 -->
           <i:EventTrigger EventName="Closing">
               <i:InvokeCommandAction Command="{Binding OnWindowClosingCommand}"
                                      CommandParameter="{Binding RelativeSource={RelativeSource AncestorType=Window}}" />
           </i:EventTrigger>
           <!-- 关闭完成事件，执行日志删除 -->
           <i:EventTrigger EventName="Closed">
               <i:InvokeCommandAction Command="{Binding OnWindowClosedCommand}" />
           </i:EventTrigger>
       </i:Interaction.Behaviors>
       <!-- 窗口内容 -->
   </Window>
   

4. ViewModel实现命令与日志删除逻辑：

   public class MainViewModel : INotifyPropertyChanged
   {
       public ICommand OnWindowClosingCommand { get; }
       public ICommand OnWindowClosedCommand { get; }
   
       public MainViewModel()
       {
           OnWindowClosingCommand = new RelayCommand<Window>(HandleWindowClosing);
           OnWindowClosedCommand = new RelayCommand(HandleWindowClosed);
       }
   
       private void HandleWindowClosing(Window window)
       {
           // 可选：添加关闭前的确认逻辑，比如阻止关闭
           // window.Closing += (s, e) => e.Cancel = true;
       }
   
       private void HandleWindowClosed()
       {
           string logFilePath = "你的日志文件绝对路径";
           try
           {
               if (File.Exists(logFilePath))
               {
                   File.Delete(logFilePath);
               }
           }
           catch (Exception ex)
           {
               // 处理删除失败的情况，比如写入临时日志或静默忽略
           }
       }
   
       // INotifyPropertyChanged 标准实现
       public event PropertyChangedEventHandler PropertyChanged;
       protected void OnPropertyChanged(string propertyName)
       {
           PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
       }
   }
   

5. 实现基础的RelayCommand（若项目未自带）：

   public class RelayCommand : ICommand
   {
       private readonly Action _execute;
       private readonly Func<bool> _canExecute;
   
       public RelayCommand(Action execute, Func<bool> canExecute = null)
       {
           _execute = execute ?? throw new ArgumentNullException(nameof(execute));
           _canExecute = canExecute;
       }
   
       public bool CanExecute(object parameter) => _canExecute?.Invoke() ?? true;
       public void Execute(object parameter) => _execute();
       public event EventHandler CanExecuteChanged
       {
           add => CommandManager.RequerySuggested += value;
           remove => CommandManager.RequerySuggested -= value;
       }
   }
   
   public class RelayCommand<T> : ICommand
   {
       private readonly Action<T> _execute;
       private readonly Func<T, bool> _canExecute;
   
       public RelayCommand(Action<T> execute, Func<T, bool> canExecute = null)
       {
           _execute = execute ?? throw new ArgumentNullException(nameof(execute));
           _canExecute = canExecute;
       }
   
       public bool CanExecute(object parameter) => _canExecute?.Invoke((T)parameter) ?? true;
       public void Execute(object parameter) => _execute((T)parameter);
       public event EventHandler CanExecuteChanged
       {
           add => CommandManager.RequerySuggested += value;
           remove => CommandManager.RequerySuggested -= value;
       }
   }
   

方案2：自定义附加属性（无第三方依赖） #

若不想引入外部包，可通过WPF附加属性实现事件与命令的绑定：

1. 创建附加属性类：

   public static class WindowCommandBinding
   {
       // Closing事件绑定命令
       public static readonly DependencyProperty ClosingCommandProperty =
           DependencyProperty.RegisterAttached(
               "ClosingCommand",
               typeof(ICommand),
               typeof(WindowCommandBinding),
               new PropertyMetadata(null, OnClosingCommandChanged));
   
       public static ICommand GetClosingCommand(Window obj) => (ICommand)obj.GetValue(ClosingCommandProperty);
       public static void SetClosingCommand(Window obj, ICommand value) => obj.SetValue(ClosingCommandProperty, value);
   
       private static void OnClosingCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
       {
           if (d is Window window)
           {
               window.Closing -= Window_Closing;
               if (e.NewValue is ICommand command) window.Closing += Window_Closing;
           }
       }
   
       private static void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
       {
           if (sender is Window window)
           {
               var command = GetClosingCommand(window);
               if (command?.CanExecute(e) ?? false) command.Execute(e);
           }
       }
   
       // Closed事件绑定命令
       public static readonly DependencyProperty ClosedCommandProperty =
           DependencyProperty.RegisterAttached(
               "ClosedCommand",
               typeof(ICommand),
               typeof(WindowCommandBinding),
               new PropertyMetadata(null, OnClosedCommandChanged));
   
       public static ICommand GetClosedCommand(Window obj) => (ICommand)obj.GetValue(ClosedCommandProperty);
       public static void SetClosedCommand(Window obj, ICommand value) => obj.SetValue(ClosedCommandProperty, value);
   
       private static void OnClosedCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
       {
           if (d is Window window)
           {
               window.Closed -= Window_Closed;
               if (e.NewValue is ICommand command) window.Closed += Window_Closed;
           }
       }
   
       private static void Window_Closed(object sender, EventArgs e)
       {
           if (sender is Window window)
           {
               var command = GetClosedCommand(window);
               if (command?.CanExecute(e) ?? false) command.Execute(e);
           }
       }
   }
   

2. 在XAML中使用附加属性：

   <Window x:Class="YourApp.MainWindow"
           xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
           xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
           xmlns:local="clr-namespace:YourApp"
           xmlns:vm="clr-namespace:YourApp.ViewModels"
           local:WindowCommandBinding.ClosingCommand="{Binding OnWindowClosingCommand}"
           local:WindowCommandBinding.ClosedCommand="{Binding OnWindowClosedCommand}">
       <Window.DataContext>
           <vm:MainViewModel />
       </Window.DataContext>
       <!-- 窗口内容 -->
   </Window>
   

3. ViewModel中的命令可直接接收事件参数（如CancelEventArgs），实现关闭前的逻辑控制。

方案选择建议 #

• 若项目已使用MVVM框架（如Prism、MvvmLight），优先使用框架自带的EventToCommand组件；
• 无框架依赖时，推荐方案1，实现简单且维护成本低；
• 若需完全原生实现，选择方案2。

内容的提问来源于stack exchange，提问作者Athens66