WPF 自定义命令

简介：

       自定义命令，有如下三种方式。 

 

介绍：

ICommand	自定义类实现其接口。基础的用法。
RoutedUICommand	实例化RoutedUICommand。可关联快捷键。
Mvvm Light	引用Mvvm Light。封装命令，使用方便。

 

使用：

1.ICommand

1.实现ICommand借口。

2.新建对应的ViewModel类，作为DataContent。亦可省略对应的ViewModel类。

1.1 常规用法

    public class CustomCommand : ICommand
    {
        //
        public Action<object> ExecuteAction { get; set; }
        public Func<object, bool> CanExecuteAction { get; set; }

        //
        // 摘要:
        //     当出现影响是否应执行该命令的更改时发生。
        public event EventHandler CanExecuteChanged;

        //
        // 摘要:
        //     定义确定此命令是否可在其当前状态下执行的方法。
        //
        // 参数:
        //   parameter:
        //     此命令使用的数据。 如果此命令不需要传递数据，则该对象可以设置为 null。
        //
        // 返回结果:
        //     如果可执行此命令，则为 true；否则为 false。
        public bool CanExecute(object parameter)
        {
            if (CanExecuteAction != null) { return CanExecuteAction(parameter); }
            return true;
        }

        //
        // 摘要:
        //     定义在调用此命令时要调用的方法。
        //
        // 参数:
        //   parameter:
        //     此命令使用的数据。 如果此命令不需要传递数据，则该对象可以设置为 null。
        public void Execute(object parameter)
        {
            if (ExecuteAction != null)
            {
                ExecuteAction(parameter);
            }
        }
    }

 

    public class CustomCommandViewModel
    {
        public CustomCommand command { get; set; }
        public void Execute(object obj)
        {
            //
            MessageBox.Show("test");
        }

        public bool CanExecute(object obj)
        {
            //
            return true;
        }
        public CustomCommandViewModel()
        {
            command = new CustomCommand();
            command.ExecuteAction += Execute;
            command.CanExecuteAction += CanExecute;
        }
    }

    <Grid>
        <StackPanel >
            <StackPanel.DataContext>
                <vm:CustomCommandViewModel/>
            </StackPanel.DataContext>

            <Button  Visibility="Visible" Command="{Binding command}" Content="test"></Button>
        </StackPanel>
    </Grid>

 

1.2 精简用法

    public class CustomCommand:ICommand
    {
        public event EventHandler CanExecuteChanged;
        public bool CanExecute(object parameter)
        {
            return true;
        }

        public void Execute(object parameter)
        {
            MessageBox.Show("test");
        }
    }

    <Grid>
        <StackPanel >
             <StackPanel.DataContext>
                <local:CustomCommand/>
            </StackPanel.DataContext>

            <Button Content="test" Command="{Binding RelativeSource={RelativeSource Self},Path=DataContext}"></Button>
        </StackPanel>
    </Grid>

 

如下两种方法绑定Command

1.2.1 Resources绑定

   <Window.Resources>
        <local:CustomCommand x:Key="command"/>
    </Window.Resources>
    <Grid>
        <StackPanel>
            <Button Command="{Binding Source={StaticResource ResourceKey=command}}" Content="test"></Button>
        </StackPanel>
    </Grid>

 

1.2.2 DataContext绑定

    <Window.DataContext>
        <local:CustomCommand/>
    </Window.DataContext>
    <Grid>
        <StackPanel >
            <Button Content="test" Command="{Binding RelativeSource={RelativeSource Self},Path=DataContext}"></Button>
        </StackPanel>
    </Grid>

 

1.2.3 控件Command绑定 

  <Grid>
        <StackPanel >
            <Button Content="test" >
                <Button.Command>
                    <local:CustomCommand/>
                </Button.Command>
            </Button>
        </StackPanel>
    </Grid>

 

 

2.RoutedUICommand

1.Execute和CanExecute放入对应的后台。

    public class RoutedCommand
    {
        public static RoutedUICommand command;
        static RoutedCommand()
        {
            InputGestureCollection inputs = new InputGestureCollection();
            inputs.Add(new KeyGesture(Key.R, ModifierKeys.Control, "Ctrl+R"));//快捷键
            command = new RoutedUICommand("command test", "command", typeof(RoutedCommand), inputs);//无需快捷键时，设置为null
        }
    }

 

        public void command_Execute(object sender, ExecutedRoutedEventArgs e)
        {
            MessageBox.Show("test");
            e.Handled = true;
        }

        public void command_CanExecute(object sender, CanExecuteRoutedEventArgs e)
        {    
            e.CanExecute = true;
            e.Handled = true;
        }

 

    <Window.CommandBindings>
        <CommandBinding Command="local:RoutedCommand.command" Executed="command_Execute" CanExecute="command_CanExecute"/>
    </Window.CommandBindings>

    <Grid>
        <StackPanel>
            <Button Command="local:RoutedCommand.command" Content="test"></Button>
        </StackPanel>
    </Grid>

 

 

3.Mvvm Light

1.Mvvm Light引用案例 ，会生成MainViewModel类。

2.实例化RelayCommand，实现Execute和CanExecute。

 public class MainViewModel : ViewModelBase
    {
        /// <summary>
        /// Initializes a new instance of the MainViewModel class.
        /// </summary>
        public MainViewModel()
        {

        }

        private int font;
        public int Font
        {
            get { return font; }
            set
            {
                if (font != value)
                {
                    font = value;
                    RaisePropertyChanged();
                }
            }
        }

        public ICommand command
        {
            get
            {
                return new RelayCommand<int>(
                    (s) => { MessageBox.Show(s.ToString()); },//执行命令
                    (s) => {return s >= 0 && s <= 200; }); //判断命令执行条件，满足条件会执行命令。无需时设置null。
            }
        }
    }

    <Window.DataContext>
        <vm:MainViewModel Font="20"/>
    </Window.DataContext>
    <Grid>
        <StackPanel >
            <TextBox x:Name="tbx" Text="{Binding Font,UpdateSourceTrigger=PropertyChanged}" FontSize="{Binding Font}"></TextBox>
            <Button  Command="{Binding command}" CommandParameter="{Binding Font}"  Content="test">
            </Button>
        </StackPanel>
    </Grid>