当CanExecute为false时，带有启用主按钮的uwp MVVM ContentDialog

Question

I try to build a ContentDialog similar to the example in https://docs.microsoft.com/en-us/uwp/api/windows.ui.xaml.controls.contentdialog with mvvm.

For the CanExecute validation I have created a derived ContentDialog class described in https://social.msdn.microsoft.com/Forums/en-US/6d5d6fd9-5f03-4cb6-b6c0-19ca01ddaab8/uwpcontentdialog-buttons-do-not-respect-canexecute?forum=wpdevelop

This works but how can I enable the button so it is clickable for the CanExecute validation.

Answer 1

There is a missing link in the CanExecuteChanged event of the ICommand interface when binding to Views. It works only when it's a perfect situation and with my experience it's mostly never perfect for it.

The trick is to call CanExecuteChanged anytime the proper value changes that should switch the CanExecute to true or false.

If you're using a relay command, what I've done is add a public method to the relay command.

public UpdateCanExecute() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);

Then in the property or properties or values that change whether or not this should return true or false just call that method.

public bool IsWorking
{
    get { return isWorking; }
    set
    {
       isWorking = value;
       Notify(nameof(IsWorking));
       MyRelayCommand.UpdateCanExecute();
    }
}

This might give you an idea of what I'm talking about. If not or if you need more help I can post more code to this answer to help clarify.

Answer 2

This is my solution. I' ve created an contentdialog extension. The extension contains

• a CancelableCommand command
• a CancelableCommandParameter parameter
• and the bindable DialogCancel property.

These are the attached properties of my extension.

namespace BSE.UI.Xaml.Controls.Extensions
{
  public static class ContentDialog
  {
    public static readonly DependencyProperty DialogCancelProperty =
                DependencyProperty.RegisterAttached("DialogCancel",
                    typeof(bool),
                    typeof(ContentDialog), new PropertyMetadata(false));

    public static readonly DependencyProperty CancelableCommandParameterProperty =
                DependencyProperty.Register("CancelableCommandParameter",
                    typeof(object),
                    typeof(ContentDialog), null);

    public static readonly DependencyProperty CancelableCommandProperty =
                DependencyProperty.RegisterAttached("CancelableCommand",
                    typeof(ICommand),
                    typeof(ContentDialog),
                    new PropertyMetadata(null, OnCancelableCommandChanged));

    public static void SetDialogCancel(DependencyObject obj, bool value)
    {
      obj.SetValue(DialogCancelProperty, value);
    }

    public static bool GetDialogCancel(DependencyObject obj)
    {
      return (bool)obj.GetValue(DialogCancelProperty);
    }

    public static ICommand GetCancelableCommand(DependencyObject obj)
    {
      return (ICommand)obj.GetValue(CancelableCommandProperty);
    }

    public static void SetCancelableCommand(DependencyObject obj, ICommand value)
    {
      obj.SetValue(CancelableCommandProperty, value);
    }

    public static object GetCancelableCommandParameter(DependencyObject obj)
    {
      return obj.GetValue(CancelableCommandParameterProperty);
    }

    public static void SetCancelableCommandParameter(DependencyObject obj, object value)
    {
      obj.SetValue(CancelableCommandParameterProperty, value);
    }

    private static void OnCancelableCommandChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
    {
      var contentDialog = obj as Windows.UI.Xaml.Controls.ContentDialog;
      if (contentDialog != null)
      {
        contentDialog.Loaded += (sender, routedEventArgs) =>
        {
         ((Windows.UI.Xaml.Controls.ContentDialog)sender).PrimaryButtonClick += OnPrimaryButtonClick;
        };
      }
    }

    private static void OnPrimaryButtonClick(Windows.UI.Xaml.Controls.ContentDialog sender, ContentDialogButtonClickEventArgs args)
    {
      var contentDialog = sender as Windows.UI.Xaml.Controls.ContentDialog;
      if (contentDialog != null)
      {
        var command = GetCancelableCommand(contentDialog);
        command?.Execute(GetCancelableCommandParameter(contentDialog));
        args.Cancel = GetDialogCancel(contentDialog);
      }
    }
  }
}

The xaml of the contentdialog looks like that

<ContentDialog
    x:Class="MyClass.Views.MyContentDialog"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:MyClass.Views"
    xmlns:controlextensions="using:BSE.UI.Xaml.Controls.Extensions"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    PrimaryButtonText="Button1"
    SecondaryButtonText="Button2"
    controlextensions:ContentDialog.DialogCancel="{Binding Cancel}"
    controlextensions:ContentDialog.CancelableCommandParameter="{Binding}"
    controlextensions:ContentDialog.CancelableCommand="{Binding MyCancelableCommand}">

</ContentDialog>

This is the viewmodel

namespace MyClass.ViewModels
{
  public class MyContentDialogViewModel : ViewModelBase
  {
    private ICommand m_myCancelableCommand;
    private bool m_cancel;

    public ICommand MyCancelableCommand=> m_myCancelableCommand ?? (m_myCancelableCommand = new RelayCommand<object>(CancelableSave));
    public bool Cancel
    {
      get
      {
        return m_cancel;
      }
      set
      {
        m_cancel = value;
        RaisePropertyChanged("Cancel");
      }
    }

    private void CancelableSave(object obj)
    {
      Cancel = !ValidateDialog();
    }

    private bool ValidateDialog()
    {
      return true// if saving successfull otherwise false
    }
  }
}