71

所以在我正在做的这个特定的 MVVM 实现中,我需要几个命令。我真的厌倦了一个个实现 ICommand 类,所以我想出了一个解决方案,但我不知道它有多好,所以这里任何 WPF 专家的输入将不胜感激。如果你能提供更好的解决方案,那就更好了。

我所做的是一个 ICommand 类和两个将对象作为参数的委托,一个委托是 void(用于 OnExecute),另一个是布尔型(用于 OnCanExecute)。因此,在我的 ICommand 的构造函数(由 ViewModel 类调用)中,我发送了两个方法,并在每个 ICommand 方法上调用了委托的方法。

它真的很好用,但我不确定这是否是一种不好的方法,或者是否有更好的方法。以下是完整的代码,任何输入将不胜感激,即使是负面的,但请具有建设性。

视图模型:

public class TestViewModel : DependencyObject
{
    public ICommand Command1 { get; set; }
    public ICommand Command2 { get; set; }
    public ICommand Command3 { get; set; }

    public TestViewModel()
    {
        this.Command1 = new TestCommand(ExecuteCommand1, CanExecuteCommand1);
        this.Command2 = new TestCommand(ExecuteCommand2, CanExecuteCommand2);
        this.Command3 = new TestCommand(ExecuteCommand3, CanExecuteCommand3);
    }

    public bool CanExecuteCommand1(object parameter)
    {
        return true;
    }

    public void ExecuteCommand1(object parameter)
    {
        MessageBox.Show("Executing command 1");
    }

    public bool CanExecuteCommand2(object parameter)
    {
        return true;
    }

    public void ExecuteCommand2(object parameter)
    {
        MessageBox.Show("Executing command 2");
    }

    public bool CanExecuteCommand3(object parameter)
    {
        return true;
    }

    public void ExecuteCommand3(object parameter)
    {
        MessageBox.Show("Executing command 3");
    }
}

指令:

public class TestCommand : ICommand
{
    public delegate void ICommandOnExecute(object parameter);
    public delegate bool ICommandOnCanExecute(object parameter);

    private ICommandOnExecute _execute;
    private ICommandOnCanExecute _canExecute;

    public TestCommand(ICommandOnExecute onExecuteMethod, ICommandOnCanExecute onCanExecuteMethod)
    {
        _execute = onExecuteMethod;
        _canExecute = onCanExecuteMethod;
    }

    #region ICommand Members

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

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

    public void Execute(object parameter)
    {
        _execute.Invoke(parameter);
    }

    #endregion
}
4

4 回答 4

88

这几乎与Karl Shifflet 演示的方式相同RelayCommand,即在哪里Execute开火Action<T>。如果您问我,一流的解决方案。

public class RelayCommand : ICommand
{
    private readonly Predicate<object> _canExecute;
    private readonly Action<object> _execute;

    public RelayCommand(Predicate<object> canExecute, Action<object> execute)
    {
        _canExecute = canExecute;
        _execute = execute;
    }

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

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

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

然后可以将其用作...

public class MyViewModel
{
    private ICommand _doSomething;
    public ICommand DoSomethingCommand
    {
        get
        {
            if (_doSomething == null)
            {
                _doSomething = new RelayCommand(
                    p => this.CanDoSomething,
                    p => this.DoSomeImportantMethod());
            }
            return _doSomething;
        }
    }
}

阅读更多:
Josh Smith(介绍人RelayCommand):模式 - 具有 MVVM 设计模式的 WPF 应用程序

于 2009-09-23T22:19:03.237 回答
17

我写了这篇关于 ICommand 接口的文章。

这个想法 - 创建一个需要两个委托的通用命令:一个在调用时ICommand.Execute (object param)调用,第二个检查您是否可以执行命令的状态(ICommand.CanExecute (object param))

需要切换事件的方法CanExecuteChanged。从用户界面元素调用它以切换状态CanExecute()命令。

public class ModelCommand : ICommand
{
    #region Constructors

    public ModelCommand(Action<object> execute)
        : this(execute, null) { }

    public ModelCommand(Action<object> execute, Predicate<object> canExecute)
    {
        _execute = execute;
        _canExecute = canExecute;
    }

    #endregion

    #region ICommand Members

    public event EventHandler CanExecuteChanged;

    public bool CanExecute(object parameter)
    {
        return _canExecute != null ? _canExecute(parameter) : true;
    }

    public void Execute(object parameter)
    {
        if (_execute != null)
            _execute(parameter);
    }

    public void OnCanExecuteChanged()
    {
        CanExecuteChanged(this, EventArgs.Empty);
    }

    #endregion

    private readonly Action<object> _execute = null;
    private readonly Predicate<object> _canExecute = null;
}
于 2011-04-08T19:14:31.387 回答
10

我刚刚创建了一个小示例,展示了如何以约定而不是配置方式实现命令。但是,它需要 Reflection.Emit() 可用。支持代码可能看起来有点奇怪,但是一旦编写它就可以多次使用。

预告片:

public class SampleViewModel: BaseViewModelStub
{
    public string Name { get; set; }

    [UiCommand]
    public void HelloWorld()
    {
        MessageBox.Show("Hello World!");
    }

    [UiCommand]
    public void Print()
    {
        MessageBox.Show(String.Concat("Hello, ", Name, "!"), "SampleViewModel");
    }

    public bool CanPrint()
    {
        return !String.IsNullOrEmpty(Name);
    }
}

}

更新:现在似乎存在一些像http://www.codeproject.com/Articles/101881/Executing-Command-Logic-in-a-View-Model这样的库来解决 ICommand 样板代码的问题。

于 2010-01-01T17:08:06.827 回答
6

@Carlo 我真的很喜欢你的实现,但我想分享我的版本以及如何在我的 ViewModel 中使用它

首先实现 ICommand

public class Command : ICommand
{
    public delegate void ICommandOnExecute();
    public delegate bool ICommandOnCanExecute();

    private ICommandOnExecute _execute;
    private ICommandOnCanExecute _canExecute;

    public Command(ICommandOnExecute onExecuteMethod, ICommandOnCanExecute onCanExecuteMethod = null)
    {
        _execute = onExecuteMethod;
        _canExecute = onCanExecuteMethod;
    }

    #region ICommand Members

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

    public bool CanExecute(object parameter)
    {
        return _canExecute?.Invoke() ?? true;
    }

    public void Execute(object parameter)
    {
        _execute?.Invoke();
    }

    #endregion
}

请注意,我已从ICommandOnExecuteICommandOnCanExecute中删除了参数,并向构造函数添加了一个 null

然后在 ViewModel 中使用

public Command CommandToRun_WithCheck
{
    get
    {
        return new Command(() =>
        {
            // Code to run
        }, () =>
        {
            // Code to check to see if we can run 
            // Return true or false
        });
    }
}

public Command CommandToRun_NoCheck
{
    get
    {
        return new Command(() =>
        {
            // Code to run
        });
    }
}

我只是觉得这种方式更干净,因为我不需要分配变量然后实例化,这一切都一次性完成。

于 2017-11-08T22:13:58.207 回答