互斥的可检查菜单项？

Question

给出以下代码：

<MenuItem x:Name="MenuItem_Root" Header="Root">
    <MenuItem x:Name="MenuItem_Item1" IsCheckable="True" Header="item1" />
    <MenuItem x:Name="MenuItem_Item2" IsCheckable="True" Header="item2"/>
    <MenuItem x:Name="MenuItem_Item3" IsCheckable="True" Header="item3"/>
</MenuItem>

在 XAML 中，有没有办法创建互斥的可检查菜单项？当用户选中item2时，item 1和3会自动取消选中。

我可以通过监视菜单上的单击事件、确定选中哪个项目并取消选中其他菜单项，在后面的代码中完成此操作。我想有一个更简单的方法。

有什么想法吗？

Answer 1

这可能不是您想要的，但您可以为 MenuItem 类编写一个扩展，该扩展允许您使用 的 GroupName 属性之类的内容RadioButton 类。我稍微修改了 这个 类似扩展的方便示例ToggleButton 控件并根据您的情况对其进行了一些修改，并得出了以下结论：

using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;

namespace WpfTest
{
     public class MenuItemExtensions : DependencyObject
     {
           public static Dictionary<MenuItem, String> ElementToGroupNames = new Dictionary<MenuItem, String>();

           public static readonly DependencyProperty GroupNameProperty =
               DependencyProperty.RegisterAttached("GroupName",
                                            typeof(String),
                                            typeof(MenuItemExtensions),
                                            new PropertyMetadata(String.Empty, OnGroupNameChanged));

           public static void SetGroupName(MenuItem element, String value)
           {
                element.SetValue(GroupNameProperty, value);
           }

           public static String GetGroupName(MenuItem element)
           {
                return element.GetValue(GroupNameProperty).ToString();
           }

           private static void OnGroupNameChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
           {
                //Add an entry to the group name collection
                var menuItem = d as MenuItem;

                if (menuItem != null)
                {
                     String newGroupName = e.NewValue.ToString();
                     String oldGroupName = e.OldValue.ToString();
                     if (String.IsNullOrEmpty(newGroupName))
                     {
                          //Removing the toggle button from grouping
                          RemoveCheckboxFromGrouping(menuItem);
                     }
                     else
                     {
                          //Switching to a new group
                          if (newGroupName != oldGroupName)
                          {
                              if (!String.IsNullOrEmpty(oldGroupName))
                              {
                                   //Remove the old group mapping
                                   RemoveCheckboxFromGrouping(menuItem);
                              }
                              ElementToGroupNames.Add(menuItem, e.NewValue.ToString());
                               menuItem.Checked += MenuItemChecked;
                          }
                     }
                }
           }

           private static void RemoveCheckboxFromGrouping(MenuItem checkBox)
           {
                ElementToGroupNames.Remove(checkBox);
                checkBox.Checked -= MenuItemChecked;
           }


           static void MenuItemChecked(object sender, RoutedEventArgs e)
           {
                var menuItem = e.OriginalSource as MenuItem;
                foreach (var item in ElementToGroupNames)
                {
                     if (item.Key != menuItem && item.Value == GetGroupName(menuItem))
                     {
                          item.Key.IsChecked = false;
                     }
                }
           }
      }
 }

然后，在 XAML 中，您可以编写：

        <MenuItem x:Name="MenuItem_Root" Header="Root">
            <MenuItem x:Name="MenuItem_Item1" YourNamespace:MenuItemExtensions.GroupName="someGroup" IsCheckable="True" Header="item1" />
            <MenuItem x:Name="MenuItem_Item2" YourNamespace:MenuItemExtensions.GroupName="someGroup" IsCheckable="True" Header="item2"/>
            <MenuItem x:Name="MenuItem_Item3" YourNamespace:MenuItemExtensions.GroupName="someGroup" IsCheckable="True" Header="item3"/>
        </MenuItem>

这有点痛苦，但它提供了不强迫您的好处编写任何附加的过程代码（当然，除了扩展类之外）来实现它。

感谢 Brad Cunningham，他是最初的 ToggleButton 解决方案的作者。

Answer 2

由于我还没有声誉，因此将其添加到底部...

尽管帕特里克的答案很有帮助，但它并不能确保无法取消选中项目。为此，应将 Checked 处理程序更改为 Click 处理程序，并更改为以下内容：

static void MenuItemClicked(object sender, RoutedEventArgs e)
{
    var menuItem = e.OriginalSource as MenuItem;
    if (menuItem.IsChecked)
    {
        foreach (var item in ElementToGroupNames)
        {
            if (item.Key != menuItem && item.Value == GetGroupName(menuItem))
            {
                item.Key.IsChecked = false;
            }
        }
    }
    else // it's not possible for the user to deselect an item
    {
        menuItem.IsChecked = true;
    }
}

Answer 3

您还可以使用行为。就像这个：

<MenuItem Header="menu">

    <MenuItem x:Name="item1" Header="item1" IsCheckable="true" ></MenuItem>
    <MenuItem x:Name="item2" Header="item2" IsCheckable="true"></MenuItem>
    <MenuItem x:Name="item3" Header="item3" IsCheckable="true" ></MenuItem>

    <i:Interaction.Behaviors>
    <local:MenuItemButtonGroupBehavior></local:MenuItemButtonGroupBehavior>
    </i:Interaction.Behaviors>

</MenuItem>


public class MenuItemButtonGroupBehavior : Behavior<MenuItem>
{
    protected override void OnAttached()
    {
        base.OnAttached();

        GetCheckableSubMenuItems(AssociatedObject)
            .ToList()
            .ForEach(item => item.Click += OnClick);
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();

        GetCheckableSubMenuItems(AssociatedObject)
            .ToList()
            .ForEach(item => item.Click -= OnClick);
    }

    private static IEnumerable<MenuItem> GetCheckableSubMenuItems(ItemsControl menuItem)
    {
        var itemCollection = menuItem.Items;
        return itemCollection.OfType<MenuItem>().Where(menuItemCandidate => menuItemCandidate.IsCheckable);
    }

    private void OnClick(object sender, RoutedEventArgs routedEventArgs)
    {
        var menuItem = (MenuItem)sender;

        if (!menuItem.IsChecked)
        {
            menuItem.IsChecked = true;
            return;
        }

        GetCheckableSubMenuItems(AssociatedObject)
            .Where(item => item != menuItem)
            .ToList()
            .ForEach(item => item.IsChecked = false);
    }
}

Answer 4

由于没有类似的答案，我在这里发布我的解决方案：

public class RadioMenuItem : MenuItem
{
    public string GroupName { get; set; }
    protected override void OnClick()
    {
        var ic = Parent as ItemsControl;
        if (null != ic)
        {
            var rmi = ic.Items.OfType<RadioMenuItem>().FirstOrDefault(i =>
                i.GroupName == GroupName && i.IsChecked);
            if (null != rmi) rmi.IsChecked = false;

            IsChecked = true;
        }
        base.OnClick();
    }
}

在 XAML 中，只需将其用作通常的 MenuItem：

<MenuItem Header="OOO">
    <local:RadioMenuItem Header="111" GroupName="G1"/>
    <local:RadioMenuItem Header="222" GroupName="G1"/>
    <local:RadioMenuItem Header="333" GroupName="G1"/>
    <local:RadioMenuItem Header="444" GroupName="G1"/>
    <local:RadioMenuItem Header="555" GroupName="G1"/>
    <local:RadioMenuItem Header="666" GroupName="G1"/>
    <Separator/>
    <local:RadioMenuItem Header="111" GroupName="G2"/>
    <local:RadioMenuItem Header="222" GroupName="G2"/>
    <local:RadioMenuItem Header="333" GroupName="G2"/>
    <local:RadioMenuItem Header="444" GroupName="G2"/>
    <local:RadioMenuItem Header="555" GroupName="G2"/>
    <local:RadioMenuItem Header="666" GroupName="G2"/>
</MenuItem>

非常简单和干净。当然，您可以通过一些额外的代码将 GroupName 设为依赖属性，这与其他代码相同。

顺便说一句，如果您不喜欢复选标记，您可以将其更改为您喜欢的任何内容：

public override void OnApplyTemplate()
{
    base.OnApplyTemplate();
    var p = GetTemplateChild("Glyph") as Path;
    if (null == p) return;
    var x = p.Width/2;
    var y = p.Height/2;
    var r = Math.Min(x, y) - 1;
    var e = new EllipseGeometry(new Point(x,y), r, r);
    // this is just a flattened dot, of course you can draw
    // something else, e.g. a star? ;)
    p.Data = e.GetFlattenedPathGeometry();
}

如果您在程序中使用了大量此 RadioMenuItem，则还有另一个更有效的版本，如下所示。文字数据是从前面的代码片段中的e.GetFlattenedPathGeometry().ToString()获取的。

private static readonly Geometry RadioDot = Geometry.Parse("M9,5.5L8.7,7.1 7.8,8.3 6.6,9.2L5,9.5L3.4,9.2 2.2,8.3 1.3,7.1L1,5.5L1.3,3.9 2.2,2.7 3.4,1.8L5,1.5L6.6,1.8 7.8,2.7 8.7,3.9L9,5.5z");
public override void OnApplyTemplate()
{
    base.OnApplyTemplate();
    var p = GetTemplateChild("Glyph") as Path;
    if (null == p) return;
    p.Data = RadioDot;
}

最后，如果您打算将其包装在项目中使用，则应该从基类中隐藏 IsCheckable 属性，因为 MenuItem 类的自动检查机制将导致无线电检查状态标记错误行为。

private new bool IsCheckable { get; }

因此，如果新手尝试像这样编译 XAML，VS 将给出错误：

//注意这是错误的用法！

//注意这是错误的用法！

Answer 5

是的，通过将每个 MenuItem 设为 RadioButton 可以轻松完成此操作。这可以通过编辑菜单项的模板来完成。

1. 右键单击文档大纲左窗格中的菜单项>编辑模板>编辑复制。这将在 Window.Resources 下添加用于编辑的代码。

2. 现在，您只需要做两处更改，非常简单。

   a。添加带有一些资源的 RadioButton 以隐藏其圆圈部分。

   b.更改 MenuItem 边框部分的 BorderThickness = 0。

   这些更改作为注释显示在下面，生成的样式的其余部分应按原样使用：

   ;
           
               
               
           
           <几何x：Key＝“复选标记”>M 0,5.1 L 1.7,5.2 L 3.4,7.1 L 8,0.4 L 9.2,0 L 3.3,10.8 Z
           
               <网格 SnapsToDevicePixels="true">
                   <矩形 x:Name="Bg" Fill="{TemplateBinding 背景}" RadiusY="2" RadiusX="2" Stroke="{TemplateBinding BorderBrush}" StrokeThickness="1"/>
                   <矩形x：名称=“InnerBorder”边距=“1”RadiusY=“2”RadiusX=“2”/>
      
                   
                       
                           
   

3. 应用样式，

Answer 6

这是一个简单的、基于 MVVM 的解决方案，它利用每个 MenuItem 的简单 IValueConverter 和 CommandParameter。

无需将任何 MenuItem 重新设计为不同类型的控件。当绑定值与 CommandParameter 不匹配时，MenuItems 将自动取消选择。

绑定到 DataContext (ViewModel) 上的 int 属性 (MenuSelection)。

<MenuItem x:Name="MenuItem_Root" Header="Root">
    <MenuItem x:Name="MenuItem_Item1" IsCheckable="True" Header="item1" IsChecked="{Binding MenuSelection, ConverterParameter=1, Converter={StaticResource MatchingIntToBooleanConverter}, Mode=TwoWay}" />
    <MenuItem x:Name="MenuItem_Item2" IsCheckable="True" Header="item2" IsChecked="{Binding MenuSelection, ConverterParameter=2, Converter={StaticResource MatchingIntToBooleanConverter}, Mode=TwoWay}" />
    <MenuItem x:Name="MenuItem_Item3" IsCheckable="True" Header="item3" IsChecked="{Binding MenuSelection, ConverterParameter=3, Converter={StaticResource MatchingIntToBooleanConverter}, Mode=TwoWay}" />
</MenuItem>

定义您的价值转换器。这将根据命令参数检查绑定值，反之亦然。

public class MatchingIntToBooleanConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        var paramVal = parameter as string;
        var objVal = ((int)value).ToString();

        return paramVal == objVal;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is bool)
        {
            var i = System.Convert.ToInt32((parameter ?? "0") as string);

            return ((bool)value)
                ? System.Convert.ChangeType(i, targetType)
                : 0;
        }

        return 0; // Returning a zero provides a case where none of the menuitems appear checked
    }
}

添加您的资源

<Window.Resources>
    <ResourceDictionary>
        <local:MatchingIntToBooleanConverter x:Key="MatchingIntToBooleanConverter"/>
    </ResourceDictionary>
</Window.Resources>

祝你好运！

Answer 7

我只是想我会提出我的解决方案，因为没有一个答案满足我的需求。我的完整解决方案在这里...

WPF MenuItem as a RadioButton

但是，基本思想是使用 ItemContainerStyle。

<MenuItem.ItemContainerStyle>
    <Style TargetType="MenuItem">
        <Setter Property="Icon" Value="{DynamicResource RadioButtonResource}"/>
        <EventSetter Event="Click" Handler="MenuItemWithRadioButtons_Click" />
    </Style>
</MenuItem.ItemContainerStyle>

并且应该添加以下事件 click ，以便在单击 MenuItem 时检查 RadioButton （否则您必须精确单击 RadioButton ）：

private void MenuItemWithRadioButtons_Click(object sender, System.Windows.RoutedEventArgs e)
{
    if (sender is MenuItem mi)
    {
        if (mi.Icon is RadioButton rb)
        {
            rb.IsChecked = true;
        }
    }
}

Answer 8

XAML 中没有内置方法可以执行此操作，您需要推出自己的解决方案或获取现有解决方案（如果可用）。

Answer 9

我使用几行代码实现了这一点：

首先声明一个变量：

MenuItem LastBrightnessMenuItem =null;

当我们考虑一组菜单项时，有可能使用单个事件处理程序。在这种情况下我们可以使用这个逻辑：

    private void BrightnessMenuClick(object sender, RoutedEventArgs e)
                {

                    if (LastBrightnessMenuItem != null)
                    {
                        LastBrightnessMenuItem.IsChecked = false;
                    }

                    MenuItem m = sender as MenuItem;
                    LastBrightnessMenuItem = m;

                    //Handle the rest of the logic here


                }

Answer 10

我发现将 MenuItem.IsChecked 绑定到变量时会得到互斥的菜单项。

但它有一个怪癖：如果单击选定的菜单项，它就会无效，如通常的红色矩形所示。我通过为 MenuItem.Click 添加一个处理程序来解决这个问题，该处理程序只需将 IsChecked 设置回 true 即可防止取消选择。

代码...我绑定到枚举类型，因此我使用枚举转换器，如果绑定属性等于提供的参数，则该转换器返回 true。这是 XAML：

    <MenuItem Header="Black"
              IsCheckable="True"
              IsChecked="{Binding SelectedColor, Converter={StaticResource EnumConverter}, ConverterParameter=Black}"
              Click="MenuItem_OnClickDisallowUnselect"/>
    <MenuItem Header="Red"
              IsCheckable="True"
              IsChecked="{Binding SelectedColor, Converter={StaticResource EnumConverter}, ConverterParameter=Red}"
              Click="MenuItem_OnClickDisallowUnselect"/>

这是背后的代码：

    private void MenuItem_OnClickDisallowUnselect(object sender, RoutedEventArgs e)
    {
        var menuItem = e.OriginalSource as MenuItem;
        if (menuItem == null) return;

        if (! menuItem.IsChecked)
        {
            menuItem.IsChecked = true;
        }
    }

Answer 11

几年后，我看到这篇文章，其中包含我写的关键字...我认为在 wpf 中有一个简单的解决方案...也许是我，但我认为为这么小的东西拥有如此庞大的武器库有点特别作为公认的解决方案。我什至没有谈论 6likes 的解决方案，我不明白在哪里单击才能获得此选项。

所以也许它真的一点也不优雅......但这里有一个简单的解决方案。它的作用很简单......循环父级包含的所有元素，将其设置为 false。大多数时候人们将这部分与其他部分分开，当然只有在这种情况下才是正确的。

private void MenuItem_Click_1(object sender, RoutedEventArgs e)
{
    MenuItem itemChecked = (MenuItem)sender;
    MenuItem itemParent = (MenuItem)itemChecked.Parent;

    foreach (MenuItem item in itemParent.Items)
    {
        if (item == itemChecked)continue;

        item.IsChecked = false;
    }
}

这很简单，xaml是一个经典的代码，绝对没有什么特别的

<MenuItem Header="test">
    <MenuItem Header="1"  Click="MenuItem_Click_1" IsCheckable="True" StaysOpenOnClick="True"/>
    <MenuItem Header="2"  Click="MenuItem_Click_1" IsCheckable="True"  StaysOpenOnClick="True"/>
</MenuItem>

当然你可能需要click方法，这不是问题，你可以创建一个接受对象发送者的方法，并且每个click方法都将使用这个方法方法。它又旧又丑，但暂时还可以用。
我有一些问题，想象这么多代码行用于这么小的事情，可能是我对 xaml 有问题，但必须这样做才能只选择一个菜单项似乎令人难以置信。

Answer 12

对@Patrick 答案的一个小补充。

正如 @MK10 提到的，该解决方案允许用户取消选择组中的所有项目。但他建议的改变现在对我不起作用。也许，WPF 模型从那时起就发生了变化，但现在当取消选中某个项目时，不会触发 Checked 事件。

为了避免这种情况，我建议处理 MenuItem 的 Unchecked 事件。

我更改了这些过程：

        private static void OnGroupNameChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (!(d is MenuItem menuItem))
                return;

            var newGroupName = e.NewValue.ToString();
            var oldGroupName = e.OldValue.ToString();
            if (string.IsNullOrEmpty(newGroupName))
            {
                RemoveCheckboxFromGrouping(menuItem);
            }
            else
            {
                if (newGroupName != oldGroupName)
                {
                    if (!string.IsNullOrEmpty(oldGroupName))
                    {
                        RemoveCheckboxFromGrouping(menuItem);
                    }
                    ElementToGroupNames.Add(menuItem, e.NewValue.ToString());
                    menuItem.Checked += MenuItemChecked;
                    menuItem.Unchecked += MenuItemUnchecked; // <-- ADDED
                }
            }
        }

        private static void RemoveCheckboxFromGrouping(MenuItem checkBox)
        {
            ElementToGroupNames.Remove(checkBox);
            checkBox.Checked -= MenuItemChecked;
            checkBox.Unchecked -= MenuItemUnchecked;   // <-- ADDED
        }

并添加了下一个处理程序：

    private static void MenuItemUnchecked(object sender, RoutedEventArgs e)
    {
        if (!(e.OriginalSource is MenuItem menuItem))
            return;

        var isAnyItemChecked = ElementToGroupNames.Any(item => item.Value == GetGroupName(menuItem) && item.Key.IsChecked);
        if (!isAnyItemChecked)
            menuItem.IsChecked = true;
    }

现在，当用户第二次单击时，选中的项目仍保持选中状态。

Answer 13

这是另一种方法——无论如何都不容易，但它兼容 MVVM、可绑定且高度可单元测试。如果您可以自由地将转换器添加到项目中，并且不介意每次打开上下文菜单时以新项目列表的形式出现一些垃圾，那么这非常有效。它满足了如何在上下文菜单中提供一组互斥的选中项的原始问题。

我认为，如果您想将所有这些提取到用户控件中，您可以将其制作成可重用的库组件，以便在您的应用程序中重用。
使用的组件是 Type3.Xaml，带有一个简单的网格、一个文本块和上下文菜单。右键单击网格中的任意位置即可显示菜单。

名为 AllValuesEqualToBooleanConverter 的值转换器用于将每个菜单项的值与组的当前值进行比较，并在当前选定的菜单项旁边显示复选标记。

使用一个代表菜单选项的简单类进行说明。示例容器使用具有 String 和 Integer 属性的 Tuple，这使得很容易将紧密耦合的人类可读文本片段与机器友好的值配对。您可以单独使用字符串或字符串和枚举来跟踪值，以便对当前内容做出决策。
Type3VM.cs 是分配给 Type3.Xaml 的 DataContext 的 ViewModel。无论您如何在现有应用程序框架中分配数据上下文，请在此处使用相同的机制。所使用的应用程序框架依赖于 INotifyPropertyChanged 将更改的值传达给 WPF 及其绑定对象。如果您有依赖属性，您可能需要稍微调整代码。

除了转换器及其长度之外，此实现的缺点是每次打开上下文菜单时都会创建一个垃圾列表。对于单用户应用程序，这可能没问题，但您应该意识到这一点。

该应用程序使用 RelayCommand 的实现，该实现可以从 Haacked 网站轻松获得，或者可以在您使用的任何框架中使用任何其他 ICommand 兼容的帮助程序类。

public class Type3VM : INotifyPropertyChanged
    {
        private List<MenuData> menuData = new List<MenuData>(new[] 
        {
            new MenuData("Zero", 0),
            new MenuData("One", 1),
            new MenuData("Two", 2),
            new MenuData("Three", 3),
        });

        public IEnumerable<MenuData> MenuData { get { return menuData.ToList(); } }

        private int selected;
        public int Selected
        {
            get { return selected; }
            set { selected = value; OnPropertyChanged(); }
        }

        private ICommand contextMenuClickedCommand;
        public ICommand ContextMenuClickedCommand { get { return contextMenuClickedCommand; } }

        private void ContextMenuClickedAction(object clicked)
        {
            var data = clicked as MenuData;
            Selected = data.Item2;
            OnPropertyChanged("MenuData");
        }

        public Type3VM()
        {
            contextMenuClickedCommand = new RelayCommand(ContextMenuClickedAction);
        }

        private void OnPropertyChanged([CallerMemberName]string propertyName = null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }

        public event PropertyChangedEventHandler PropertyChanged;
    }

    public class MenuData : Tuple<String, int>
    {
        public MenuData(String DisplayValue, int value) : base(DisplayValue, value) { }
    }

<UserControl x:Class="SampleApp.Views.Type3"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:Views="clr-namespace:SampleApp.Views"
             xmlns:Converters="clr-namespace:SampleApp.Converters"
             xmlns:ViewModels="clr-namespace:SampleApp.ViewModels"
             mc:Ignorable="d" 
             d:DesignHeight="300" d:DesignWidth="300"
             d:DataContext="{d:DesignInstance ViewModels:Type3VM}"
             >
    <UserControl.Resources>
        <Converters:AllValuesEqualToBooleanConverter x:Key="IsCheckedVisibilityConverter" EqualValue="True" NotEqualValue="False" />
    </UserControl.Resources>
    <Grid>
        <Grid.ContextMenu>
            <ContextMenu ItemsSource="{Binding MenuData, Mode=OneWay}">
                <ContextMenu.ItemContainerStyle>
                    <Style TargetType="MenuItem" >
                        <Setter Property="Header" Value="{Binding Item1}" />
                        <Setter Property="IsCheckable" Value="True" />
                        <Setter Property="IsChecked">
                            <Setter.Value>
                                <MultiBinding Converter="{StaticResource IsCheckedVisibilityConverter}" Mode="OneWay">
                                    <Binding Path="DataContext.Selected" RelativeSource="{RelativeSource FindAncestor, AncestorType={x:Type Views:Type3}}"  />
                                    <Binding Path="Item2" />
                                </MultiBinding>
                            </Setter.Value>
                        </Setter>
                        <Setter Property="Command" Value="{Binding Path=DataContext.ContextMenuClickedCommand, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Views:Type3}}}" />
                        <Setter Property="CommandParameter" Value="{Binding .}" />
                    </Style>
                </ContextMenu.ItemContainerStyle>
            </ContextMenu>
        </Grid.ContextMenu>
        <Grid.RowDefinitions><RowDefinition Height="*" /></Grid.RowDefinitions>
        <Grid.ColumnDefinitions><ColumnDefinition Width="*" /></Grid.ColumnDefinitions>
        <TextBlock Grid.Row="0" Grid.Column="0" FontSize="30" Text="Right Click For Menu" />
    </Grid>
</UserControl>

public class AreAllValuesEqualConverter<T> : IMultiValueConverter
{
    public T EqualValue { get; set; }
    public T NotEqualValue { get; set; }

    public object Convert(object[] values, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        T returnValue;

        if (values.Length < 2)
        {
            returnValue = EqualValue;
        }

        // Need to use .Equals() instead of == so that string comparison works, but must check for null first.
        else if (values[0] == null)
        {
            returnValue = (values.All(v => v == null)) ? EqualValue : NotEqualValue;
        }
        else
        {
            returnValue = (values.All(v => values[0].Equals(v))) ? EqualValue : NotEqualValue;
        }

        return returnValue;
    }

    public object[] ConvertBack(object value, Type[] targetTypes, object parameter, System.Globalization.CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

[ValueConversion(typeof(object), typeof(Boolean))]
public class AllValuesEqualToBooleanConverter : AreAllValuesEqualConverter<Boolean>
{ }

Answer 14

You can hook both check and uncheck event for the MenuItem and inside the event you can call a common method like below:

        private void MenuItem_Unchecked(object sender, RoutedEventArgs e)
        {
            this.UpdateCheckeditem(sender as MenuItem);
        }

        private void MenuItem_Checked(object sender, RoutedEventArgs e)
        {
            this.UpdateCheckeditem(sender as MenuItem);
        }

        private void UpdateCheckedstatus(MenuItem item)
        {
             MenuItem itemChecked = (MenuItem)sender;
            MenuItem itemParent = (MenuItem)itemChecked.Parent;

            foreach (MenuItem item in itemParent.Items)
            {

                if (item != itemChecked && item.IsChecked)
                {
                    item.IsChecked = false;
                    break;
                }
            }
        }

I think this will give you the expected behavior.

Answer 15

只需为 MenuItem 创建一个模板，其中将包含一个 RadioButton，其 GroupName 设置为某个值。
您还可以更改 RadioButtons 的模板，使其看起来像 MenuItem 的默认检查字形（可以使用 Expression Blend 轻松提取）。

就是这样！

Answer 16

你可以这样做：

        <Menu>
            <MenuItem Header="File">
                <ListBox BorderThickness="0" Background="Transparent">
                    <ListBox.ItemsPanel>
                        <ItemsPanelTemplate>
                            <StackPanel />
                        </ItemsPanelTemplate>
                    </ListBox.ItemsPanel>
                    <ListBox.ItemContainerStyle>
                        <Style TargetType="{x:Type ListBoxItem}">
                            <Setter Property="Template">
                                <Setter.Value>
                                    <ControlTemplate>
                                        <MenuItem IsCheckable="True" IsChecked="{Binding IsSelected, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type ListBoxItem}}}" Header="{Binding Content, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type ListBoxItem}}}" />
                                    </ControlTemplate>
                                </Setter.Value>
                            </Setter>
                        </Style>
                    </ListBox.ItemContainerStyle>
                    <ListBox.Items>
                        <ListBoxItem Content="Test" />
                        <ListBoxItem Content="Test2" />
                    </ListBox.Items>
                </ListBox>
            </MenuItem>
        </Menu>

它在视觉上有一些奇怪的副作用（当你使用它时你会看到），但它仍然有效

Answer 17

这是另一种使用 RoutedUICommands（公共枚举属性）和 DataTriggers 的方法。这是一个非常冗长的解决方案。不幸的是，我没有看到任何使 Style.Triggers 变小的方法，因为我不知道如何说 Binding Value 是唯一不同的东西？ （顺便说一句，对于 MVVMers 来说，这是一个糟糕的例子。我将所有内容都放在 MainWindow 类中只是为了简单起见。）

MainWindow.xaml：

<Window x:Class="MutuallyExclusiveMenuItems.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:view="clr-namespace:MutuallyExclusiveMenuItems"
        Title="MainWindow" Height="350" Width="525">

  <Window.CommandBindings>
    <CommandBinding Command="{x:Static view:MainWindow.MenuItem1Cmd}" 
        CanExecute="CanExecute"
        Executed="MenuItem1Execute" />
    <CommandBinding Command="{x:Static view:MainWindow.MenuItem2Cmd}" 
        CanExecute="CanExecute"
        Executed="MenuItem2Execute" />
    <CommandBinding Command="{x:Static view:MainWindow.MenuItem3Cmd}" 
        CanExecute="CanExecute"
        Executed="MenuItem3Execute" />
  </Window.CommandBindings>

  <Window.InputBindings>
    <KeyBinding Command="{x:Static view:MainWindow.MenuItem1Cmd}" Gesture="Ctrl+1"/>
    <KeyBinding Command="{x:Static view:MainWindow.MenuItem2Cmd}" Gesture="Ctrl+2"/>
    <KeyBinding Command="{x:Static view:MainWindow.MenuItem3Cmd}" Gesture="Ctrl+3"/>
  </Window.InputBindings>

  <DockPanel>
    <DockPanel DockPanel.Dock="Top">
      <Menu>
        <MenuItem Header="_Root">
          <MenuItem Command="{x:Static view:MainWindow.MenuItem1Cmd}" 
                    InputGestureText="Ctrl+1">
            <MenuItem.Style>
              <Style>
                <Style.Triggers>
                  <DataTrigger Binding="{Binding CurrentMenuItem, Mode=OneWay}" 
                               Value="{x:Static view:MainWindow+CurrentItemEnum.EnumItem1}">
                    <Setter Property="MenuItem.IsChecked" Value="True"/>
                  </DataTrigger>
                </Style.Triggers>
              </Style>
            </MenuItem.Style>
          </MenuItem>
          <MenuItem Command="{x:Static view:MainWindow.MenuItem2Cmd}"
                    InputGestureText="Ctrl+2">
            <MenuItem.Style>
              <Style>
                <Style.Triggers>
                  <DataTrigger Binding="{Binding CurrentMenuItem, Mode=OneWay}" 
                               Value="{x:Static view:MainWindow+CurrentItemEnum.EnumItem2}">
                    <Setter Property="MenuItem.IsChecked" Value="True"/>
                  </DataTrigger>
                </Style.Triggers>
              </Style>
            </MenuItem.Style>
          </MenuItem>
          <MenuItem Command="{x:Static view:MainWindow.MenuItem3Cmd}"
                    InputGestureText="Ctrl+3">
            <MenuItem.Style>
              <Style>
                <Style.Triggers>
                  <DataTrigger Binding="{Binding CurrentMenuItem, Mode=OneWay}" 
                               Value="{x:Static view:MainWindow+CurrentItemEnum.EnumItem3}">
                    <Setter Property="MenuItem.IsChecked" Value="True"/>
                  </DataTrigger>
                </Style.Triggers>
              </Style>
            </MenuItem.Style>
          </MenuItem>
        </MenuItem>
      </Menu>
    </DockPanel>
  </DockPanel>
</Window>

MainWindow.xaml.cs：

using System.Windows;
using System.Windows.Input;
using System.ComponentModel;

namespace MutuallyExclusiveMenuItems
{
  public partial class MainWindow : Window, INotifyPropertyChanged
  {
    public MainWindow()
    {
      InitializeComponent();
      DataContext = this;
    }

    #region Enum Property
    public enum CurrentItemEnum { EnumItem1, EnumItem2, EnumItem3 };

    private CurrentItemEnum _currentMenuItem;
    public CurrentItemEnum CurrentMenuItem
    {
      get { return _currentMenuItem; }
      set
      {
        _currentMenuItem = value;
        OnPropertyChanged("CurrentMenuItem");
      }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged(string propertyName)
    {
      PropertyChangedEventHandler handler = PropertyChanged;
      if (handler != null)
        handler(this, new PropertyChangedEventArgs(propertyName));
    }
    #endregion Enum Property

    #region Commands
    public static RoutedUICommand MenuItem1Cmd = 
      new RoutedUICommand("Item_1", "Item1cmd", typeof(MainWindow));
    public void MenuItem1Execute(object sender, ExecutedRoutedEventArgs e)
    {
      CurrentMenuItem = CurrentItemEnum.EnumItem1;
    }
    public static RoutedUICommand MenuItem2Cmd = 
      new RoutedUICommand("Item_2", "Item2cmd", typeof(MainWindow));
    public void MenuItem2Execute(object sender, ExecutedRoutedEventArgs e)
    {
      CurrentMenuItem = CurrentItemEnum.EnumItem2;
    }
    public static RoutedUICommand MenuItem3Cmd = 
      new RoutedUICommand("Item_3", "Item3cmd", typeof(MainWindow));
    public void MenuItem3Execute(object sender, ExecutedRoutedEventArgs e)
    {
      CurrentMenuItem = CurrentItemEnum.EnumItem3;
    }
    public void CanExecute(object sender, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = true;
    }
    #endregion Commands
  }
}

Answer 18

这是我为此目的创建的自定义控件。
它正确处理选中、取消选中、单击事件和组名称更改。

如果您愿意，可以覆盖菜单项的样式并将复选标记更改为单选标记，但这不是必需的：

public class RadioMenuItem : MenuItem
{
    private bool abortCheckChange = false;

    [DefaultValue("")]
    public string GroupName
    {
        get => (string)GetValue(GroupNameProperty);
        set => SetValue(GroupNameProperty, value);
    }

    public static readonly DependencyProperty GroupNameProperty =
        DependencyProperty.Register(nameof(GroupName), typeof(string), typeof(RadioMenuItem),
            new PropertyMetadata("", (d, e) => ((RadioMenuItem)d).OnGroupNameChanged((string)e.OldValue, (string)e.NewValue)));


    static RadioMenuItem()
    {
        IsCheckedProperty.OverrideMetadata(typeof(RadioMenuItem),
            new FrameworkPropertyMetadata(null, (d, o) => ((RadioMenuItem)d).abortCheckChange ? d.GetValue(IsCheckedProperty) : o));
    }

    protected override DependencyObject GetContainerForItemOverride()
    {
        return new RadioMenuItem();
    }

    protected override void OnClick()
    {
        //This will handle correctly the click, but prevents the unchecking.
        //So the menu item acts that is correctly clicked (e.g. the menu disappears
        //but the user can only check, not uncheck the item.
        if (IsCheckable && IsChecked) abortCheckChange = true;
        base.OnClick();
        abortCheckChange = false;
    }

    protected override void OnChecked(RoutedEventArgs e)
    {
        base.OnChecked(e);
        //If the menu item is checked, other items of the same group will be unchecked.
        if (IsChecked) UncheckOtherGroupItems();
    }

    protected virtual void OnGroupNameChanged(string oldGroupName, string newGroupName)
    {
        //If the menu item enters on another group and is checked, other items will be unchecked.
        if (IsChecked) UncheckOtherGroupItems();
    }

    private void UncheckOtherGroupItems()
    {
        if (IsCheckable)
        {
            IEnumerable<RadioMenuItem> radioItems = Parent is ItemsControl parent ? parent.Items.OfType<RadioMenuItem>()
                .Where((item) => item.IsCheckable && (item.DataContext == parent.DataContext || item.DataContext != DataContext)) : null;

            if (radioItems != null)
            {
                foreach (RadioMenuItem item in radioItems)
                {
                    if (item != this && item.GroupName == GroupName)
                    {
                        //This will uncheck all other items on the same group.
                        item.IsChecked = false;
                    }
                }
            }
        }
    }
}

示例：

<Grid Background="Red" HorizontalAlignment="Left" Height="125" Margin="139,120,0,0" VerticalAlignment="Top" Width="120">
    <Grid.ContextMenu>
        <ContextMenu>
            <MenuItem IsCheckable="True" Header="Normal check 1"/>
            <MenuItem IsCheckable="True" Header="Normal check 2"/>
            <Separator/>
            <local:RadioMenuItem IsCheckable="True" Header="Radio check 1" GroupName="Group1"/>
            <local:RadioMenuItem IsCheckable="True" Header="Radio check 2" GroupName="Group1"/>
            <local:RadioMenuItem IsCheckable="True" Header="Radio check 3" GroupName="Group1"/>
            <Separator/>
            <local:RadioMenuItem IsCheckable="True" Header="Radio check 4" GroupName="Group2"/>
            <local:RadioMenuItem IsCheckable="True" Header="Radio check 5" GroupName="Group2"/>
        </ContextMenu>
    </Grid.ContextMenu>
</Grid>

Answer 19

实现互斥工具条菜单项的最佳且正确的方法是：

private void ChangecheckedItemsOnDropdownItemsClick(object sender, ToolStripItemClickedEventArgs e)
{
 //get the currently checked item
 ToolStripMenuItem itemChecked = (ToolStripMenuItem)sender;

 // loop through the dropdown items for the main ToolStrip item
 foreach (ToolStripMenuItem item in NameofParentToolStripMenuItem.DropDownItems)
 {
 // if the current item is same as checked item, continue
 if (item == itemChecked) continue;
  // else uncheck the item
 else
  item.Checked = false;
 }
}

请将 NameofParentToolStripMenuItem 替换为您想要具有此属性的菜单项。