如何使用ICommand輕鬆管理UpdateCanExecute/CanExecute for Multiplex模型

Question

當使用ICommand接口並綁定到通過Command和CommandParameters（或者只是命令）的控件時，通常會意識到按鈕/控件不會自動變爲啓用/禁用（調用CanExecute）當正在使用的值更改。

Answer 1

只要有人在這裏感興趣的是一個小回購，迫使ICommand隨時根據需要通過RelayCommand進行更新。這不需要在視圖中做出額外的工作，這使得IMO成爲現實。

Auto Relay Command Example

中繼命令僅僅是如何容易自動化ICommand接口，並且不意味着是對修復所有溶液的例子。

這裏是RelayCommand

public class RelayCommand : ICommand 
{ 
    private readonly RelayCommandBindings relayCommandBindings; 
    public event EventHandler CanExecuteChanged; 

    internal RelayCommand(RelayCommandBindings relayCommandBindings) 
    { 
     this.relayCommandBindings = relayCommandBindings; 

     relayCommandBindings.BindingModel.PropertyChanged += (s, e) => 
     { 
      if (relayCommandBindings.BindingProperties.Any(p => p == e.PropertyName)) 
       CanExecuteChanged?.Invoke(this, EventArgs.Empty); 
     }; 
    } 

    public bool CanExecute(object parameter) => (relayCommandBindings.CanExecuteChecks?.All(p => p.Invoke(parameter))).GetValueOrDefault(); 
    public void Execute(object parameter) => relayCommandBindings?.Execute?.Invoke(parameter); 
} 

這裏是RelayCommandBindings

internal class RelayCommandBindings 
{ 
    public Action<object> Execute { get; set; } 
    public IEnumerable<Predicate<object>> CanExecuteChecks { get; set; } 
    public INotifyPropertyChanged BindingModel { get; set; } 
    public IEnumerable<string> BindingProperties { get; set; } 
} 

這裏是視圖模型

public class MultiplexViewModel : INotifyPropertyChanged 
{ 
    private const string NoName = "(no name)"; 
    private bool isActive; 
    private bool isActiveChanging; 
    private string name; 
    private readonly MultiPlexModel multiPlexModel; 
    private readonly SynchronizationContext synchronizationContext; 

    public MultiplexViewModel() 
    { 
     multiPlexModel = new MultiPlexModel(); 
     synchronizationContext = SynchronizationContext.Current; 

     var bindingProperties = new[] 
     { 
      nameof(IsActive), 
      nameof(IsActiveChanging) 
     }; 

     var setNewNameBindings = new RelayCommandBindings() 
     { 
      Execute = async (obj) => await multiPlexModel.StartMultiplexModelAsync(obj.ToString()), 
      CanExecuteChecks = new List<Predicate<object>> 
      { 
       (obj) => IsValidName(obj?.ToString()), 
       (obj) => IsActive == false, 
       (obj) => IsActiveChanging == false 
      }, 
      BindingModel = this, 
      BindingProperties = bindingProperties 
     }; 

     var stopMultiplexBindings = new RelayCommandBindings() 
     { 
      Execute = async (obj) => await multiPlexModel.StopMultiplexModelAsync(), 
      CanExecuteChecks = new List<Predicate<object>> 
      { 
       (obj) => IsActive == true, 
       (obj) => IsActiveChanging == false 
      }, 
      BindingModel = this, 
      BindingProperties = bindingProperties 
     }; 

     SetNewNameCommand = new RelayCommand(setNewNameBindings); 
     StopMultiplexCommand = new RelayCommand(stopMultiplexBindings); 

     multiPlexModel.PropertyChanged += (s, e) => GetType().GetProperties().Where(p => p.Name == e.PropertyName).FirstOrDefault()?.SetValue(this, multiPlexModel.GetType().GetProperty(e.PropertyName).GetValue(multiPlexModel)); 
    } 

    public event PropertyChangedEventHandler PropertyChanged; 
    public void Notify([CallerMemberName] string propertyName = "") => synchronizationContext.Post((o) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)), null); 

    public bool IsActive 
    { 
     get { return isActive; } 
     private set 
     { 
      isActive = value; 
      Notify(); 
     } 
    } 

    public bool IsActiveChanging 
    { 
     get { return isActiveChanging; } 
     private set 
     { 
      isActiveChanging = value; 
      Notify(); 
     } 
    } 

    public string Name 
    { 
     get { return string.IsNullOrEmpty(name) ? NoName : name; } 
     private set 
     { 
      name = value; 
      Notify(); 
     } 
    } 

    private bool IsValidName(string name) => (name?.StartsWith("@")).GetValueOrDefault(); 
    public RelayCommand SetNewNameCommand { get; private set; } 
    public RelayCommand StopMultiplexCommand { get; private set; } 
} 

這裏是模型

public class MultiPlexModel : INotifyPropertyChanged 
{ 
    private bool isActive; 
    private bool isActiveChanging; 
    private string name; 

    public event PropertyChangedEventHandler PropertyChanged; 
    public void Notify([CallerMemberName] string propertyName = "") => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); 

    public bool IsActive 
    { 
     get { return isActive; } 
     private set 
     { 
      isActive = value; 
      Notify(); 
     } 
    } 

    public bool IsActiveChanging 
    { 
     get { return isActiveChanging; } 
     private set 
     { 
      isActiveChanging = value; 
      Notify(); 
     } 
    } 

    public string Name 
    { 
     get { return name; } 
     private set 
     { 
      name = value; 
      Notify(); 
     } 
    } 

    public async Task StartMultiplexModelAsync(string newName) 
    { 
     await Task.Run(async() => 
     { 
      if (IsActiveChanging) 
       return; 

      IsActiveChanging = true; 
      await Task.Delay(2000); 

      Name = newName; 
      IsActive = true; 
      IsActiveChanging = false; 
     }); 
    } 

    public async Task StopMultiplexModelAsync() 
    { 
     await Task.Run(async() => 
     { 
      if (IsActiveChanging) 
       return; 

      IsActiveChanging = true; 
      await Task.Delay(2000); 

      Name = string.Empty; 
      IsActive = false; 
      IsActiveChanging = false; 
     }); 
    } 

} 

這裏是查看

<UserControl.DataContext> 
    <ViewModels:MultiplexViewModel /> 
</UserControl.DataContext> 

<StackPanel Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"> 

    <TextBlock Text="Auto Relay Command Example" 
       Margin="12, 40, 12, 12" 
       FontSize="32" 
       TextWrapping="Wrap" /> 

    <TextBlock Text="The purpose of this application is to demonstrate a method for automatically activating CanExecute in ICommand. This automatically triggers buttons to become enabled/disabled based on various binding properties at once." 
       Margin="12" 
       TextWrapping="Wrap" /> 

    <TextBlock Text="The name of the multiplex can only be set once if it starts with the @ symbol and the multiplex is not active." 
       Margin="12" 
       TextWrapping="Wrap" /> 

    <TextBlock Text="The multiplex is started when the name is being properly set. At that time the multiplex cannot be altered... once it is set it cannot be reset until it has been stopped." 
       Margin="12" 
       TextWrapping="Wrap" /> 

    <TextBlock Text="There is no code behind, triggers, converters, or other tricks used to make this work. This is purely binding to the commands in the ViewModel. The magic is in the RelayCommand and RelayCommandBindings in the ViewModels namespace." 
       Margin="12" 
       TextWrapping="Wrap" /> 

    <TextBox Name="TextBoxName" 
      Text="{Binding Name, Mode=OneWay}" 
      Margin="12" /> 

    <Button Content="Set New Name" 
      Margin="12" 
      Command="{Binding SetNewNameCommand}" 
      CommandParameter="{Binding Text, ElementName=TextBoxName}" /> 

    <Button Content="Stop Multiplex" 
      Margin="12" 
      Command="{Binding StopMultiplexCommand}" /> 

    <StackPanel Margin="12"> 
     <TextBlock Text="Multiplex Changing" /> 
     <TextBlock Text="{Binding IsActiveChanging}" /> 
    </StackPanel> 

    <StackPanel Margin="12"> 
     <TextBlock Text="Multiplex Active" /> 
     <TextBlock Text="{Binding IsActive}" /> 
    </StackPanel> 

    <StackPanel Margin="12"> 
     <TextBlock Text="Multiplex Name" /> 
     <TextBlock Text="{Binding Name}" /> 
    </StackPanel> 

</StackPanel> 

圖片---------

這裏的按鈕來設置新名稱啓用.. 。

個

這裏的按鈕，同時激活再次禁用...

這裏名稱設置和停止按鈕被激活......

這裏，一旦停止，視圖又回到了開始。

在這個例子中，你看到不同的屬性設置有直線前進命令，在視圖的方式應該是結合，IMO觀的基調。只是認爲這會有所幫助...