WPF自定义下拉按钮：为下拉项添加独立点击事件的实现问题

Hey there! Let's figure out how to get those dropdown item clicks working properly. The issue you're facing with PART_DropdownButton returning null makes total sense—here's why and how to fix it, plus a clean, reusable approach for your custom control.

Why Your Current Approach Isn't Working #

The PART_DropdownButton TextBlock lives inside a DataTemplate, which generates a new instance for every item in your ItemsSource. When you call GetTemplateChild in the custom control's OnApplyTemplate, you're only looking at the parent control's template—you can't access the individual template instances created for each dropdown item. That's why you're getting null.

The Best Solution: Use WPF Command Binding #

For reusable WPF controls (especially ones you're packaging into a DLL), the command pattern is the way to go. It's clean, follows WPF's design principles, and lets users of your control easily attach custom logic to each dropdown item.

Let's walk through the steps:

1. Update Your DropdownItem Class

Add an ICommand property to store the action for each item, instead of a string method name. This is far more maintainable and WPF-friendly:

public class DropdownItem
{
    public string Text { get; set; }
    public string Icon { get; set; }
    public string Tooltip { get; set; }
    // Add this command property
    public ICommand ClickCommand { get; set; }
}

2. Fix the DataTemplate in generic.xaml

Bind the MouseBinding directly to the ClickCommand property of each DropdownItem. You don't need to name the TextBlock anymore:

<mah:DropDownButton.ItemTemplate>
    <DataTemplate>
        <StackPanel Orientation="Horizontal" Margin="0" ToolTip="{Binding Tooltip}">
            <StackPanel.InputBindings>
                <!-- Bind to the ClickCommand on the current DropdownItem -->
                <MouseBinding Command="{Binding ClickCommand}" MouseAction="LeftClick" />
            </StackPanel.InputBindings>
            <Image Source="{Binding Icon}" Width="16"></Image>
            <TextBlock Text="{Binding Text}" Margin="4,0,0,0"/>
        </StackPanel>
    </DataTemplate>
</mah:DropDownButton.ItemTemplate>

3. Implement a Simple RelayCommand

If you're not using a MVVM framework (like Prism or MVVM Light), you'll need a basic implementation of ICommand to wrap your methods. Add this class to your project:

public class RelayCommand : ICommand
{
    private readonly Action _execute;
    private readonly Func<bool> _canExecute;

    public RelayCommand(Action execute, Func<bool> canExecute = null)
    {
        _execute = execute ?? throw new ArgumentNullException(nameof(execute));
        _canExecute = canExecute;
    }

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

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

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

4. Attach Custom Methods in MainWindow.xaml.cs

Now you can create your dropdown items and assign unique commands to each one, pointing to your custom methods:

public ObservableCollection<DropdownItem> Items { get; set; }

public MainWindow()
{
    InitializeComponent();
    Items = new ObservableCollection<DropdownItem>
    {
        new DropdownItem
        {
            Text = "Text1",
            Icon = "Images/Icon1.png",
            Tooltip = "Action for Text1",
            ClickCommand = new RelayCommand(OnText1Clicked)
        },
        new DropdownItem
        {
            Text = "Text2",
            Icon = "Images/Icon2.png",
            Tooltip = "Action for Text2",
            ClickCommand = new RelayCommand(OnText2Clicked)
        }
    };
    DataContext = this;
}

private void OnText1Clicked()
{
    // Your custom logic for Text1 click
    MessageBox.Show("Text1 was clicked!");
}

private void OnText2Clicked()
{
    // Your custom logic for Text2 click
    MessageBox.Show("Text2 was clicked!");
}

Why This Works #

Each DropdownItem now carries its own command that points directly to the method you want to run. When the user clicks the item, WPF automatically executes the bound command. This approach keeps your custom control clean (no messy event handling inside the control itself) and gives full flexibility to anyone using your DLL—they just need to assign commands to their dropdown items.

Bonus: If You Really Want to Use Method Names (Not Recommended) #

If you absolutely need to pass method names as strings (though this is not best practice), you could use reflection to find and invoke the method at runtime. But this is error-prone, harder to maintain, and breaks WPF's design patterns. Stick with commands if you can!

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