用户控件中绑定DependencyProperty并在嵌套属性变更时调用CanExecute的实现方案

Great question! Since you can't modify the closed SearchParams class and want to avoid relying on CommandManager, here are two solid, practical solutions to trigger SearchAsyncCommand.RaiseCanExecuteChanged() whenever nested properties of SearchParams change:

Solution 1: Monitor Control Changes in SearchParamsControl and Notify the ViewModel #

This approach captures user-driven changes to nested properties directly in your control, then relays that event to your ViewModel to refresh the command's state.

Step 1: Update Control XAML to Enable Source Update Notifications #

For every ComboBox (or other input control) bound to a nested SearchParams property, add NotifyOnSourceUpdated="True" and attach a SourceUpdated event handler. This ensures we get notified when the control's value syncs back to the SearchParams source:

<!-- Inside SearchParamsControl.xaml -->
<ComboBox SelectedItem="{Binding SearchParams.Category, NotifyOnSourceUpdated=True}"
          SourceUpdated="OnSearchParamPropertyUpdated" />
<ComboBox SelectedItem="{Binding SearchParams.DateRange, NotifyOnSourceUpdated=True}"
          SourceUpdated="OnSearchParamPropertyUpdated" />
<!-- Repeat for all other nested property bindings -->

Step 2: Add a Custom Event in the Control Code-Behind #

In SearchParamsControl.xaml.cs, handle the SourceUpdated events and expose a custom event to notify external components (like your MainWindow/ViewModel) about the change:

public partial class SearchParamsControl : UserControl
{
    // Custom event to signal nested property changes
    public event EventHandler SearchParamsNestedChanged;

    public SearchParamsControl()
    {
        InitializeComponent();
    }

    private void OnSearchParamPropertyUpdated(object sender, DataTransferEventArgs e)
    {
        // Trigger the custom event whenever a nested property is updated
        SearchParamsNestedChanged?.Invoke(this, EventArgs.Empty);
    }

    // Your existing SearchParams DependencyProperty definition stays the same
    public static readonly DependencyProperty SearchParamsProperty =
        DependencyProperty.Register(nameof(SearchParams), typeof(SearchParams), typeof(SearchParamsControl), new FrameworkPropertyMetadata(null));

    public SearchParams SearchParams
    {
        get => (SearchParams)GetValue(SearchParamsProperty);
        set => SetValue(SearchParamsProperty, value);
    }
}

Step 3: Connect the Event to Your ViewModel's Command #

You have two options here to keep things clean:

Option A: Code-Behind Binding (Simple & Direct)

In your MainWindow's code-behind, hook up the control's custom event to refresh your command:

public MainWindow()
{
    InitializeComponent();
    var viewModel = (MainViewModel)DataContext;
    searchParamsControl.SearchParamsNestedChanged += (s, e) =>
    {
        viewModel.SearchAsyncCommand.RaiseCanExecuteChanged();
    };
}

Option B: MVVM-Style with Behaviors (No Code-Behind)

If you prefer to avoid code-behind coupling, use the Microsoft.Xaml.Behaviors.Wpf library to bind the event to a ViewModel command:

<!-- Inside MainWindow.xaml -->
<Window xmlns:b="http://schemas.microsoft.com/xaml/behaviors">
    <local:SearchParamsControl SearchParams="{Binding MySearchParams}">
        <b:Interaction.Triggers>
            <b:EventTrigger EventName="SearchParamsNestedChanged">
                <b:InvokeCommandAction Command="{Binding RefreshSearchCommand}" />
            </b:EventTrigger>
        </b:Interaction.Triggers>
    </local:SearchParamsControl>
</Window>

Then add the refresh command to your ViewModel:

public class MainViewModel : INotifyPropertyChanged
{
    public ICommand SearchAsyncCommand { get; }
    public ICommand RefreshSearchCommand { get; }

    public MainViewModel()
    {
        SearchAsyncCommand = new RelayCommand(ExecuteSearch, CanExecuteSearch);
        RefreshSearchCommand = new RelayCommand(() => SearchAsyncCommand.RaiseCanExecuteChanged());
    }

    // Your existing ExecuteSearch, CanExecuteSearch, and INotifyPropertyChanged implementation here
}

Solution 2: Listen for SearchParams Property Changes in the ViewModel with TypeDescriptor #

This approach keeps all logic in the ViewModel and doesn't require modifying your control. It uses TypeDescriptor to monitor property changes on the closed SearchParams class (even though it doesn't implement INotifyPropertyChanged).

Step 1: Update the ViewModel's SearchParams Property #

Modify the property setter to add/remove property change listeners whenever the SearchParams instance changes:

public class MainViewModel : INotifyPropertyChanged
{
    private SearchParams _mySearchParams;
    public SearchParams MySearchParams
    {
        get => _mySearchParams;
        set
        {
            if (_mySearchParams != value)
            {
                // Clean up listeners for the old instance to prevent memory leaks
                if (_mySearchParams != null)
                {
                    foreach (PropertyDescriptor prop in TypeDescriptor.GetProperties(_mySearchParams))
                    {
                        prop.RemoveValueChanged(_mySearchParams, OnSearchParamsPropertyChanged);
                    }
                }

                _mySearchParams = value;

                // Add listeners for all properties on the new instance
                if (_mySearchParams != null)
                {
                    foreach (PropertyDescriptor prop in TypeDescriptor.GetProperties(_mySearchParams))
                    {
                        prop.AddValueChanged(_mySearchParams, OnSearchParamsPropertyChanged);
                    }
                }

                OnPropertyChanged(nameof(MySearchParams));
                // Refresh command state when the instance is replaced
                SearchAsyncCommand.RaiseCanExecuteChanged();
            }
        }
    }

    private void OnSearchParamsPropertyChanged(object sender, EventArgs e)
    {
        // Refresh command state whenever any nested property changes
        SearchAsyncCommand.RaiseCanExecuteChanged();
    }

    // Your existing SearchAsyncCommand and INotifyPropertyChanged implementation here
}

Which Solution Should You Choose? #

Pick the option that best fits your project's scalability needs and existing architecture.

内容的提问来源于stack exchange，提问作者Billy