RelayCommand最佳实践

Question

我正在使用RelayCommands (他们在一个单独的类中)工作了大约一个月，我觉得他们在声明它们时有点笨重。下面我有三种方法，我可以考虑如何声明一个RelayCommand。

在第一种情况下，我声明我的ICommand，然后在加载ViewModel时，构造指向代码中的方法的RelayCommand。

public class MyViewModel
{
    public ICommand MyCommand { get; private set; }

    public MyViewModel()
    {
        MyCommand = new RelayCommand(MyMethod, CanMyMethod);
    }

    private void MyMethod()
    {
         // Do something here ...
    }

    private bool CanMyMethod()
    {
         return string.IsNullOrEmpty(MyString) ? false : true;
    }
}

第二种方法是一次做每件事。

public ICommand MyCommand
    {
        get
        {
            return new RelayCommand(
                () =>
                {
                    // Do something here ...
                },
                () =>
                    string.IsNullOrEmpty(MyString) ? false : true);
        }
    }

现在，我计划在一个特定的Commands中使用相当多的ViewModel编写一个应用程序。我也不能将ViewModel拆分到更小的ViewModels中，因为所有的controls都必须一起工作。

所以我的问题是：

1. 声明和构造ICommands的最佳方法是什么？这是我的方法之一还是有更简单的方法？
2. 考虑到单个ICommands中有50多个ViewModel，用每种方法来维护概览有多难。
3. 我希望将来能在Windows 7、8和10上发布我的应用程序。如果我只使用RelayCommands，那么对.NET4.5有什么限制吗？
4. 除了RelayCommands，我还发现了这个项目：卡利本-微。它允许您执行类似以下代码的操作。与RelayCommands相比，有没有人知道这在性能上有多好？这只是一个额外的问题，不需要被回答的帖子标记为答案。

Xaml (视图)

<Button x:Name="Login" Content="Log in" />

ViewModel

public bool CanLogin(string username, string password)
{
    return !String.IsNullOrEmpty(username) && !String.IsNullOrEmpty(password);
}

public string Login(string username, string password)
{
    ...
}

Answer 1

请参阅下面的答案。

1. 声明和构造ICommands的最佳方法是什么？这是我的方法之一还是有更简单的方法？Ans:您可以采用组合方法。如果执行方法非常小，则可以使用RelayCommnd，否则可以在单独的类中实现自己的ICommand。这将提高视图模型的可读性以及代码的模块化。。
2. 考虑到单个ICommands中有50多个ViewModel，用每种方法来维护概览有多难。 Ans :在Ans 1中覆盖
3. 我希望将来能在Windows 7、8和10上发布我的应用程序。如果我只使用RelayCommands，是否需要考虑到.NET4.5的限制？Ans:我在Windows 7或8中没有看到任何限制，但对Windows10.不确定。
4. 除了RelayCommands，我还发现了这个项目:卡里伯-微。它允许您执行类似以下代码的操作。与RelayCommands相比，有没有人知道这在性能上有多好？这只是一个额外的问题，不需要被回答的帖子标记为答案。Ans:我不确定RelayCommands的源代码在卡里本-微。但是如果它使用CommandManager来实现CanExecute功能。然后，当所有用户输入发生更改时，命令管理器将被触发，因此，如果CanExecute方法中有一些很重的逻辑，这将导致性能问题。

Answer 2

下面是我喜欢的模式，它基本上是方法1的一个变体：

public class MyViewModel
{
    private readonly RelayCommand myCommand;

    public MyViewModel()
    {
        this.myCommand = new RelayCommand(this.DoStuff, () => ...);
    }

    public ICommand MyCommand
    {
        get { return this.myCommand; }
    }

    private void DoStuff() { ... }
}

这样做的优点是在您的RelayCommand实现(如RaiseCanExecuteChanged)上保留额外的方法，以便从您的视图模型中使用，但是只向使用者公开一个ICommand实例。

Answer 3

我同意Krowi的观点，第一种方法更容易理解。但是我会把你的中继命令放到它自己的类中，这样你就可以重复使用它了：

public class RelayCommand : ICommand
{
    #region Fields
    readonly Action<object> _execute;
    readonly Predicate<object> _canExecute;
    #endregion // Fields

    #region Constructors
    public RelayCommand(Action<object> execute)
        : this(execute, null)
    {
    }

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

        _execute = execute;
        _canExecute = canExecute;
    }
    #endregion

    #region ICommand Members
    [DebuggerStepThrough]
    public bool CanExecute(object parameter)
    {
        return _canExecute == null ? true : _canExecute(parameter);
    }

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

    public void Execute(object parameter)
    {
        _execute(parameter);
    }
    #endregion
}