wpf mvvm 的冗余 ICommand 类

Question

我仍在学习 wpf，但是我熟悉如何在 wpf c# 中设置 mvvm。然而，当涉及到 ICommand/RelayCommand 的东西时，它对我来说有点令人困惑。在过去的几个月里，我编译了一些 ICommand 类的实现，以创建我的工具。但是，我现在已经阅读了几篇文章并且已经查看了足够长的代码，我正在寻找可以帮助我的人并简单地说这里发生了什么，如果是这样，我如何组合/清理这些类。目前代码似乎是多余的，我不确定如何优化它。希望这不是要求太多。谢谢。

我想在此维护的两件重要的事情是能够将参数传递给命令，如 RelayCommand 的第一个用法示例中所示。其次，启用/禁用命令的能力，如第二个命令所示。

所以在我的工具中我有这个助手类。 1.我没有得到这个RelayCommand.cs中两个类之间的使用差异。有一个公共类和一个内部类。 2. 两者都需要还是可以结合使用？ RelayCommand.cs

using System;
using System.Windows.Input;

namespace WpfApplication1.Helper
{
    public class RelayCommand<T> : ICommand
    {
        private readonly Action<T> execute;
        private readonly Predicate<T> canExecute;

        public RelayCommand(Action<T> execute, Predicate<T> canExecute = null)
        {
            if (execute == null)
                throw new ArgumentNullException("execute");
            this.execute = execute;
            this.canExecute = canExecute;
        }

        public bool CanExecute(object parameter)
        {
            if (parameter == null)
            {
                return true;
            }
            else
            {
                return canExecute == null || canExecute((T)parameter);
            }
        }

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

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

    // added
    internal class RelayCommand : ICommand
    {
        private readonly Predicate<object> canExecute;
        private readonly Action<object> execute;

        public RelayCommand(Action<object> execute, Predicate<object> canExecute = null)
        {
            if (execute == null)
                throw new ArgumentNullException("execute");
            this.execute = execute;
            this.canExecute = canExecute;
        }

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

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

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

我在名为 Customer.cs 的类对象中使用 RelayCommand.cs 的示例

private ICommand addNewLicense_Command;
public ICommand AddNewLicense_Command
{
    get
    {
        return addNewLicense_Command ?? (addNewLicense_Command = new RelayCommand<Customer>(n =>
        {
            AddNewLicense_Execute(n);
        }));
    }
}

那么在我的 MainViewModel.cs 中，我在上面提到的 Helper 类所属的同一个项目中还有另一个 ICommand 类。这门课有必要吗？它看起来与 RelayCommand 类非常相似。

public class CommandHandler : ICommand
{
    private Action _action;
    private bool _canExecute;
    public CommandHandler(Action action, bool canExecute)
    {
        _action = action;
        _canExecute = canExecute;
    }

    public bool CanExecute(object parameter)
    {
        return _canExecute;
    }

    public event EventHandler CanExecuteChanged;

    public void Execute(object parameter)
    {
        _action();
    }
}

我在 MainViewModel.cs 中使用 CommandHandler 的示例

private ICommand addNewUser_Command;
public ICommand AddNewUser_Command
{
    get
    {
        return addNewUser_Command ?? (addNewUser_Command = new CommandHandler(() => AddNewUser_Execute(), true));
    }
}

Answer 1

如果您使用像 MVVM Lite 这样的库，那么它将为您提供 RelayCommand 实现。当您不需要传入的参数时，无论哪种方式都使用非泛型，例如“确定”按钮：

public ICommand OkCommand { get { return new RelayCommand(Ok); } }
protected virtual void Ok()
{
    // ... do something ...
}

相关的 XAML 类似于：

<Button Content="Ok" Command="{Binding OkCommand}" IsDefault="True" />

要传递参数时使用泛型：

public ICommand OpenClientCommand { get { return new RelayCommand<Client>(OnOpenClient); } }
private void OnOpenClient(Client client)
{
    // ... do something with client ...
}

这种情况下需要通过命令参数传入一个Client对象：

<Button Content="Open" Command="{Binding OpenClientCommand}" CommandParameter="{Binding SelectedClient}"/>

与事件触发器一起使用时传递参数也很方便，例如你可以添加这样的东西来拦截你的 MainWindow 的 Closing 事件：

<i:Interaction.Triggers>
    <i:EventTrigger EventName="Closing">
        <cmd:EventToCommand Command="{Binding ClosingCommand}" PassEventArgsToCommand="True" />
    </i:EventTrigger>
</i:Interaction.Triggers>

此触发器将消息参数传递到您的处理程序中，这样您就有机会在用户尚未保存更改时取消它：

public ICommand ClosingCommand { get { return new RelayCommand<CancelEventArgs>(OnClosing); } }
private void OnClosing(CancelEventArgs args)
{
    if (!PromptUserForClose())
        args.Cancel = true;
}

Answer 2

您所拥有的 RelayCommand 就是您所需要的。如果您想禁用该命令，您可以在构造函数中传递一个方法：

return addNewLicense_Command ?? (addNewLicense_Command = new RelayCommand<Customer>(n =>
    {
        AddNewLicense_Execute(n);
    },AllowAddNeLicense));

...

bool AllowAddNewLicense() 
{
    return _allowAddEnabled;
}

称为 CommandHandler 的第二个类只是 ICommand 的另一个实现。不同之处在于您可以在构造函数中传递“启用”布尔值，这意味着除非您创建它的新实例，否则它将保持不变。在 RelayCommand 中，您可以传递一个每次都会执行的函数*，这样您就可以影响结果。