WPF (Windows Presentation Foundation) 中的命令设计模式是一种用于分离用户界面逻辑和业务逻辑的方法。在WPF中，这种模式通过命令接口（如 ICommand）实现，使得用户界面组件（如按钮、菜单项等）可以触发不直接与它们相关的逻辑操作。

ICommand 接口

WPF中的命令设计模式主要围绕 ICommand 接口展开。这个接口定义了命令模式的核心功能，包括：

• Execute(object parameter): 当命令被触发时执行的方法。
• CanExecute(object parameter): 确定命令是否可以在当前状态下执行的方法。
• CanExecuteChanged: 当命令的可执行状态改变时发出的事件。

实现 ICommand

在实践中，你会创建实现了 ICommand 接口的类。这些类封装了命令的执行逻辑和状态。例如，你可能有一个保存数据的命令，它只在数据已修改时可用。

绑定命令

在XAML中，你可以将UI元素的事件（如按钮的点击事件）绑定到实现了 ICommand 的命令对象。这通过数据绑定完成，通常是将UI元素的 Command 属性绑定到视图模型（ViewModel）中的命令对象。

示例

假设你有一个 SaveCommand，它实现了 ICommand 接口。你可以在视图模型中创建这个命令的实例，并在XAML中将按钮的 Command 属性绑定到这个命令：

<Button Command="{Binding SaveCommand}" Content="Save" />

在这个例子中，当按钮被点击时，SaveCommand 的 Execute 方法将被调用。

创建RelayCommand类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;

namespace WpfApp_Command
{
    class RelayCommand : ICommand
    {
        private readonly Action<object> execute;
        private readonly Predicate<object> canExecute;

        public RelayCommand(Action<object> execute, Predicate<object> canExecute = null)
        {
            this.execute = execute;
            this.canExecute = canExecute;
        }

        public event EventHandler CanExecuteChanged
        {
            add { CommandManager.RequerySuggested += value; }
            remove { CommandManager.RequerySuggested -= value; }
        }

        public bool CanExecute(object? parameter)
        {
            return canExecute == null || canExecute(parameter);
        }

        public void Execute(object? parameter)
        {
            execute(parameter);
        }
    }
}

创建ViewModel类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;

namespace WpfApp_Command
{
    class ViewModel
    {
        public ICommand SaveCommand { get; private set; }

        public ViewModel()
        {
            SaveCommand = new RelayCommand(_ => Save(), _ => CanSave());
        }

        private void Save()
        {
            // 保存的逻辑

            MessageBox.Show("保存的逻辑");
        }

        private bool CanSave()
        {
            // 确定是否可以保存

            //MessageBox.Show("确定是否可以保存");
            return true;
        }
    }
}

将ViewModel实例设置为窗口的DataContext。你可以在代码中这样做：

public MainWindow()
{
    InitializeComponent();
    this.DataContext = new ViewModel();
}

或者在XAML中这样写：

<Window.DataContext>
    <local:ViewModel />
</Window.DataContext>

以上就是使用数据绑定的命令的基本示例。请注意，实际应用中的代码可能会更复杂，因为你可能需要处理更多的情况，例如异步操作、错误处理等等。

在这个示例中，我们使用了数据绑定来将按钮的Command属性绑定到ViewModel的SaveCommand属性。这意味着当你点击这个按钮时，会执行SaveCommand命令。

运行效果

问题：为什么先触发CanSave()？

在WPF中，CanExecute方法（在这个例子中是CanSave方法）用于确定命令是否可以执行。这是一种安全检查，用于在可能的情况下防止命令的不适当执行。

当你对某个命令调用CanExecute（或类似的方法）时，WPF会自动处理并禁用不能执行的命令关联的UI元素。例如，如果SaveCommand关联的按钮的CanExecute方法返回false，那么这个按钮将被自动禁用，用户无法点击它。

在CanExecute方法中，你通常会检查能否安全地执行命令的条件。例如，对于一个"保存"命令，你可能会检查以下条件：

• 用户是否已经做出了改变？
• 是否存在未保存的数据？
• 是否存在任何阻止保存的验证错误？

这些条件会根据你的具体应用程序和命令的具体需求而变化。在决定这些条件时，你应该确保只有在所有必要的条件都满足时，CanExecute方法才返回true。

以下是一个例子，展示了一个可能的CanSave方法实现：

private bool CanSave()
{
    // 检查是否存在未保存的数据
    if (!_dataService.HasChanges())
    {
        return false;
    }

    // 检查是否存在任何验证错误
    if (_validationService.HasErrors())
    {
        return false;
    }

    // 所有条件都满足，可以保存
    return true;
}

在这个示例中，我们首先检查是否存在未保存的数据。如果没有，那么我们就不能保存，所以返回false。然后，我们检查是否存在任何验证错误。如果有，那么我们不能保存，所以返回false。如果以上所有检查都通过了，那么我们就可以保存，所以返回true。

其它用法

在WPF中，命令（Command）是一种用于处理UI操作（如点击按钮、选择菜单项等）的方式。命令允许你将UI操作的处理逻辑与UI元素（如按钮和菜单）分离，这有助于你遵从MVVM（Model-View-ViewModel）设计模式。

在WPF中，有很多预定义的命令，例如Copy, Paste和Delete命令，你可以直接在你的应用程序中使用。你也可以创建自己的自定义命令。

以下是一个使用命令的基本示例。在这个例子中，我们创建了一个名为MyCommand的自定义命令，并在一个按钮上使用了它。

首先，让我们定义MyCommand命令：

public static class CustomCommands
{
    public static readonly RoutedUICommand MyCommand = new RoutedUICommand(
        "My Command",
        "MyCommand",
        typeof(CustomCommands),
        new InputGestureCollection
        {
            new KeyGesture(Key.M, ModifierKeys.Control)
        });
}

在这个示例中，我们创建了一个名为MyCommand的自定义命令。我们为这个命令指定了一个描述（“My Command”），一个名称（“MyCommand”），一个所有者类型（CustomCommands）和一个输入手势（Ctrl+M）。

接下来，让我们在按钮上使用MyCommand命令，并定义命令的执行逻辑和可执行条件：

<Button Command="local:CustomCommands.MyCommand"
        Content="Execute My Command"/>

public MainWindow()
{
    InitializeComponent();

    CommandBinding myCommandBinding = new CommandBinding(
        CustomCommands.MyCommand,
        MyCommandExecuted,
        MyCommandCanExecute);

    this.CommandBindings.Add(myCommandBinding);
}

private void MyCommandExecuted(object sender, ExecutedRoutedEventArgs e)
{
    MessageBox.Show("My Command has been executed.");
}

private void MyCommandCanExecute(object sender, CanExecuteRoutedEventArgs e)
{
    e.CanExecute = true;
}

在这个示例中，我们首先在按钮上使用了MyCommand命令。然后，我们创建了一个CommandBinding，将MyCommand命令与执行逻辑MyCommandExecuted和可执行条件MyCommandCanExecute关联。最后，我们将这个CommandBinding添加到窗口的CommandBindings集合。

在MyCommandExecuted方法中，我们定义了命令的执行逻辑。在这个例子中，当命令被执行时，我们显示一个消息框。

在MyCommandCanExecute方法中，我们定义了命令的可执行条件。在这个例子中，我们让命令始终可以执行。如果你需要根据特定条件来决定命令是否可以执行，你可以在这个方法中进行检查。例如，如果你有一个“保存”命令，你可能希望只在用户做出改变时才让这个命令可执行。