Question

我试图找到一个简单的例子，其中枚举按原样显示。我见过的所有例子都试图添加漂亮的显示字符串，但我不希望这种复杂性。

基本上我有一个包含我绑定的所有属性的类，首先将DataContext设置为此类，然后在xaml文件中指定这样的绑定：

<ComboBox ItemsSource="{Binding Path=EffectStyle}"/>

但是这不会将ComboBox中的枚举值显示为项目。

Answer 1

您可以通过在Window Loaded事件处理程序中放置以下代码从代码中执行此操作，例如：

yourComboBox.ItemsSource = Enum.GetValues(typeof(EffectStyle)).Cast<EffectStyle>();

如果需要在XAML中绑定它，则需要使用ObjectDataProvider创建可用作绑定源的对象：

<Window x:Class="YourNamespace.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:System="clr-namespace:System;assembly=mscorlib"
        xmlns:StyleAlias="clr-namespace:Motion.VideoEffects">
    <Window.Resources>
        <ObjectDataProvider x:Key="dataFromEnum" MethodName="GetValues"
                            ObjectType="{x:Type System:Enum}">
            <ObjectDataProvider.MethodParameters>
                <x:Type TypeName="StyleAlias:EffectStyle"/>
            </ObjectDataProvider.MethodParameters>
        </ObjectDataProvider>
    </Window.Resources>
    <Grid>
        <ComboBox ItemsSource="{Binding Source={StaticResource dataFromEnum}}"
                  SelectedItem="{Binding Path=CurrentEffectStyle}" />
    </Grid>
</Window>

请注意下一个代码：

xmlns:System="clr-namespace:System;assembly=mscorlib"
xmlns:StyleAlias="clr-namespace:Motion.VideoEffects"

指导如何映射您可以在MSDN上阅读的命名空间和程序集。

Answer 2

我喜欢在ViewModel中定义我绑定的所有对象，因此我尽量避免在xaml中使用<ObjectDataProvider>。

我的解决方案不使用View中定义的数据，也不使用代码隐藏。只有一个DataBinding，一个可重用的ValueConverter，一个获取任何Enum类型描述集合的方法，以及一个要绑定到ViewModel中的单个属性。

当我想将Enum绑定到ComboBox时，我想要显示的文字永远不会匹配Enum的值，所以我使用[Description()]属性来给它我在ComboBox中想要看到的文字。如果我在游戏中有一个字符类枚举，它看起来像这样：

public enum PlayerClass
{
  // add an optional blank value for default/no selection
  [Description("")]
  NOT_SET = 0,
  [Description("Shadow Knight")]
  SHADOW_KNIGHT,
  ...
}

首先，我使用几种方法创建了辅助类来处理枚举。一种方法获取特定值的描述，另一种方法获取所有值及其对类型的描述。

public static class EnumHelper
{
  public static string Description(this Enum value)
  {
    var attributes = value.GetType().GetField(value.ToString()).GetCustomAttributes(typeof(DescriptionAttribute), false);
    if (attributes.Any())
      return (attributes.First() as DescriptionAttribute).Description;

    // If no description is found, the least we can do is replace underscores with spaces
    // You can add your own custom default formatting logic here
    TextInfo ti = CultureInfo.CurrentCulture.TextInfo;
    return ti.ToTitleCase(ti.ToLower(value.ToString().Replace("_", " ")));
  }

  public static IEnumerable<ValueDescription> GetAllValuesAndDescriptions(Type t)
  {
    if (!t.IsEnum)
      throw new ArgumentException($"{nameof(t)} must be an enum type");

    return Enum.GetValues(t).Cast<Enum>().Select((e) => new ValueDescription() { Value = e, Description = e.Description() }).ToList();
  }
}

接下来，我们创建一个ValueConverter。继承自MarkupExtension使得在XAML中使用更加容易，因此我们不必将其声明为资源。

[ValueConversion(typeof(Enum), typeof(IEnumerable<ValueDescription>))]
public class EnumToCollectionConverter : MarkupExtension, IValueConverter
{
  public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
  {
    return EnumHelper.GetAllValuesAndDescriptions(value.GetType());
  }
  public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
  {
    return null;
  }
  public override object ProvideValue(IServiceProvider serviceProvider)
  {
    return this;
  }
}

我的ViewModel只需要View可以为组合框的SelectedValue和ItemsSource绑定的1个属性：

private PlayerClass playerClass;

public PlayerClass SelectedClass
{
  get { return playerClass; }
  set
  {
    if (playerClass != value)
    {
      playerClass = value;
      OnPropertyChanged(nameof(SelectedClass));
    }
  }
}

最后绑定ComboBox视图（使用ValueConverter绑定中的ItemsSource ...

<ComboBox ItemsSource="{Binding Path=SelectedClass, Converter={x:EnumToCollectionConverter}, Mode=OneTime}"
          SelectedValuePath="Value"
          DisplayMemberPath="Description"
          SelectedValue="{Binding Path=SelectedClass}" />

要实施此解决方案，您只需复制我的EnumHelper课程和EnumToCollectionConverter课程。它们将与任何枚举一起使用。此外，我没有在此处包含它，但ValueDescription类只是一个包含2个公共对象属性的简单类，一个名为Value，一个名为Description。您可以自行创建，也可以更改代码以使用Tuple<object, object>或KeyValuePair<object, object>

Answer 3

我使用了另一种使用MarkupExtension的解决方案。

我创建了提供项目来源的课程：

public class EnumToItemsSource : MarkupExtension
{
    private readonly Type _type;

    public EnumToItemsSource(Type type)
    {
        _type = type;
    }

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        return Enum.GetValues(_type)
            .Cast<object>()
            .Select(e => new { Value = (int)e, DisplayName = e.ToString() });
    }
}

几乎所有......现在在XAML中使用它：

    <ComboBox DisplayMemberPath="DisplayName"
          ItemsSource="{persons:EnumToItemsSource {x:Type enums:States}}"
          SelectedValue="{Binding Path=WhereEverYouWant}"
          SelectedValuePath="Value" />

将'枚举：州'更改为您的枚举

Answer 4

使用ObjectDataProvider：

<ObjectDataProvider x:Key="enumValues"
   MethodName="GetValues" ObjectType="{x:Type System:Enum}">
      <ObjectDataProvider.MethodParameters>
           <x:Type TypeName="local:ExampleEnum"/>
      </ObjectDataProvider.MethodParameters>
 </ObjectDataProvider>

然后绑定到静态资源：

ItemsSource="{Binding Source={StaticResource enumValues}}"

基于this article

Answer 5

尼克的回答确实帮助了我，但我意识到它可以稍微调整一下，以避免额外的类，ValueDescription。我记得框架中已经存在KeyValuePair类，因此可以使用它。

代码只是略有变化：

public static IEnumerable<KeyValuePair<string, string>> GetAllValuesAndDescriptions<TEnum>() where TEnum : struct, IConvertible, IComparable, IFormattable
    {
        if (!typeof(TEnum).IsEnum)
        {
            throw new ArgumentException("TEnum must be an Enumeration type");
        }

        return from e in Enum.GetValues(typeof(TEnum)).Cast<Enum>()
               select new KeyValuePair<string, string>(e.ToString(),  e.Description());
    }


public IEnumerable<KeyValuePair<string, string>> PlayerClassList
{
   get
   {
       return EnumHelper.GetAllValuesAndDescriptions<PlayerClass>();
   }
}

最后是XAML：

<ComboBox ItemSource="{Binding Path=PlayerClassList}"
          DisplayMemberPath="Value"
          SelectedValuePath="Key"
          SelectedValue="{Binding Path=SelectedClass}" />

我希望这对其他人有帮助。

Answer 6

你需要在枚举中创建一个值数组，可以通过调用System.Enum.GetValues()创建，并传递你想要项目的枚举的Type。

如果为ItemsSource属性指定了此属性，则应使用所有枚举值填充它。您可能希望将SelectedItem绑定到EffectStyle（假设它是同一个枚举的属性，并包含当前值）。

Answer 7

上述所有帖子都错过了一个简单的伎俩。可以从SelectedValue的绑定中找出如何自动填充ItemsSource以使您的XAML标记正好。

<Controls:EnumComboBox SelectedValue="{Binding Fool}"/>

例如在我的ViewModel中我有

public enum FoolEnum
    {
        AAA, BBB, CCC, DDD

    };


    FoolEnum _Fool;
    public FoolEnum Fool
    {
        get { return _Fool; }
        set { ValidateRaiseAndSetIfChanged(ref _Fool, value); }
    }

ValidateRaiseAndSetIfChanged是我的INPC钩子。你的可能会有所不同。

EnumComboBox的实现如下，但首先我需要一个小帮手来获取我的枚举字符串和值

    public static List<Tuple<object, string, int>> EnumToList(Type t)
    {
        return Enum
            .GetValues(t)
            .Cast<object>()
            .Select(x=>Tuple.Create(x, x.ToString(), (int)x))
            .ToList();
    }

和主类（注意我使用ReactiveUI通过WhenAny挂钩属性更改）

using ReactiveUI;
using ReactiveUI.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using System.Windows;
using System.Windows.Documents;

namespace My.Controls
{
    public class EnumComboBox : System.Windows.Controls.ComboBox
    {
        static EnumComboBox()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(EnumComboBox), new FrameworkPropertyMetadata(typeof(EnumComboBox)));
        }

        protected override void OnInitialized( EventArgs e )
        {
            base.OnInitialized(e);

            this.WhenAnyValue(p => p.SelectedValue)
                .Where(p => p != null)
                .Select(o => o.GetType())
                .Where(t => t.IsEnum)
                .DistinctUntilChanged()
                .ObserveOn(RxApp.MainThreadScheduler)
                .Subscribe(FillItems);
        }

        private void FillItems(Type enumType)
        {
            List<KeyValuePair<object, string>> values = new List<KeyValuePair<object,string>>();

            foreach (var idx in EnumUtils.EnumToList(enumType))
            {
                values.Add(new KeyValuePair<object, string>(idx.Item1, idx.Item2));
            }

            this.ItemsSource = values.Select(o=>o.Key.ToString()).ToList();

            UpdateLayout();
            this.ItemsSource = values;
            this.DisplayMemberPath = "Value";
            this.SelectedValuePath = "Key";

        }
    }
}

你还需要在Generic.XAML中正确设置样式，否则你的盒子不会呈现任何东西，你会把你的头发拉出来。

<Style TargetType="{x:Type local:EnumComboBox}" BasedOn="{StaticResource {x:Type ComboBox}}">
</Style>

就是这样。这显然可以扩展到支持i18n但会使帖子更长。

Answer 8

public class EnumItemsConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (!value.GetType().IsEnum)
            return false;

        var enumName = value.GetType();
        var obj = Enum.Parse(enumName, value.ToString());

        return System.Convert.ToInt32(obj);
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return Enum.ToObject(targetType, System.Convert.ToInt32(value));
    }
}

如果你直接绑定到枚举对象模型属性，你应该使用这种Enum值转换器扩展Rogers和Greg的答案。

Answer 9

通用应用似乎有点不同;它没有全功能XAML的全部功能。对我有用的是：

我创建了一个枚举值列表作为枚举（未转换为字符串或整数）并将ComboBox ItemsSource绑定到
然后我可以将ComboBox ItemSelected绑定到我的公共属性其类型是有问题的枚举

为了好玩，我掀起了一个小模板课来帮助解决这个问题并将其发布到MSDN Samples pages。额外的位让我可以选择覆盖枚举的名称，让我隐藏一些枚举。我的代码看起来很糟糕，就像尼克（上图），我希望我之前看到过。

Answer 10

这个问题有很多很好的答案，我谦虚地提交了我的。我发现我的更简单，更优雅。它只需要一个值转换器。

给出一个枚举...

public enum ImageFormat
{
    [Description("Windows Bitmap")]
    BMP,
    [Description("Graphics Interchange Format")]
    GIF,
    [Description("Joint Photographic Experts Group Format")]
    JPG,
    [Description("Portable Network Graphics Format")]
    PNG,
    [Description("Tagged Image Format")]
    TIFF,
    [Description("Windows Media Photo Format")]
    WDP
}

和一个值转换器...

public class ImageFormatValueConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is ImageFormat format)
        {
            return GetString(format);
        }

        return null;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is string s)
        {
            return Enum.Parse(typeof(ImageFormat), s.Substring(0, s.IndexOf(':')));
        }
        return null;
    }

    public string[] Strings => GetStrings();

    public static string GetString(ImageFormat format)
    {
        return format.ToString() + ": " + GetDescription(format);
    }

    public static string GetDescription(ImageFormat format)
    {
        return format.GetType().GetMember(format.ToString())[0].GetCustomAttribute<DescriptionAttribute>().Description;

    }
    public static string[] GetStrings()
    {
        List<string> list = new List<string>();
        foreach (ImageFormat format in Enum.GetValues(typeof(ImageFormat)))
        {
            list.Add(GetString(format));
        }

        return list.ToArray();
    }
}

资源...

    <local:ImageFormatValueConverter x:Key="ImageFormatValueConverter"/>

XAML声明...

    <ComboBox Grid.Row="9" ItemsSource="{Binding Source={StaticResource ImageFormatValueConverter}, Path=Strings}"
              SelectedItem="{Binding Format, Converter={StaticResource ImageFormatValueConverter}}"/>

查看模型...

    private ImageFormat _imageFormat = ImageFormat.JPG;
    public ImageFormat Format
    {
        get => _imageFormat;
        set
        {
            if (_imageFormat != value)
            {
                _imageFormat = value;
                OnPropertyChanged();
            }
        }
    }

产生的组合框...

Answer 11

我喜欢tom.maruska's answer，但我需要支持我的模板在运行时可能会遇到的任何枚举类型。为此，我必须使用绑定来指定标记扩展的类型。我能够从nicolay.anykienko的this answer工作，想出一个非常灵活的标记扩展，无论如何我都能想到它。消耗如下：

<ComboBox SelectedValue="{Binding MyEnumProperty}" 
          SelectedValuePath="Value"
          ItemsSource="{local:EnumToObjectArray SourceEnum={Binding MyEnumProperty}}" 
          DisplayMemberPath="DisplayName" />

上面引用的mashed up标记扩展的源代码：

class EnumToObjectArray : MarkupExtension
{
    public BindingBase SourceEnum { get; set; }

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        IProvideValueTarget target = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;
        DependencyObject targetObject;
        DependencyProperty targetProperty;

        if (target != null && target.TargetObject is DependencyObject && target.TargetProperty is DependencyProperty)
        {
            targetObject = (DependencyObject)target.TargetObject;
            targetProperty = (DependencyProperty)target.TargetProperty;
        }
        else
        {
            return this;
        }

        BindingOperations.SetBinding(targetObject, EnumToObjectArray.SourceEnumBindingSinkProperty, SourceEnum);

        var type = targetObject.GetValue(SourceEnumBindingSinkProperty).GetType();

        if (type.BaseType != typeof(System.Enum)) return this;

        return Enum.GetValues(type)
            .Cast<Enum>()
            .Select(e => new { Value=e, Name = e.ToString(), DisplayName = Description(e) });
    }

    private static DependencyProperty SourceEnumBindingSinkProperty = DependencyProperty.RegisterAttached("SourceEnumBindingSink", typeof(Enum)
                       , typeof(EnumToObjectArray), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));

    /// <summary>
    /// Extension method which returns the string specified in the Description attribute, if any.  Oherwise, name is returned.
    /// </summary>
    /// <param name="value">The enum value.</param>
    /// <returns></returns>
    public static string Description(Enum value)
    {
        var attrs = value.GetType().GetField(value.ToString()).GetCustomAttributes(typeof(DescriptionAttribute), false);
        if (attrs.Any())
            return (attrs.First() as DescriptionAttribute).Description;

        //Fallback
        return value.ToString().Replace("_", " ");
    }
}

Answer 12

它非常好用且简单。
xml

<ComboBox ItemsSource="{Binding MyEnumArray}">

.cs

public Array MyEnumArray
{
  get { return Enum.GetValues(typeof(MyEnum)); }
}

Answer 13

简单明了的解释： http://brianlagunas.com/a-better-way-to-data-bind-enums-in-wpf/

xmlns:local="clr-namespace:BindingEnums"
xmlns:sys="clr-namespace:System;assembly=mscorlib"

...

<Window.Resources>
    <ObjectDataProvider x:Key="dataFromEnum" MethodName="GetValues"
                        ObjectType="{x:Type sys:Enum}">
        <ObjectDataProvider.MethodParameters>
            <x:Type TypeName="local:Status"/>
        </ObjectDataProvider.MethodParameters>
    </ObjectDataProvider>
</Window.Resources>

...

<Grid>
    <ComboBox HorizontalAlignment="Center" VerticalAlignment="Center" MinWidth="150"
              ItemsSource="{Binding Source={StaticResource dataFromEnum}}"/>
</Grid>

Answer 14

如果你绑定到ViewModel上的实际枚举属性，而不是枚举的int表示，那么事情会变得棘手。我发现有必要绑定到字符串表示，而不是所有上述示例中所期望的int值。

您可以通过将简单文本框绑定到要在ViewModel上绑定到的属性来判断是否是这种情况。如果显示文本，则绑定到字符串。如果显示数字，则绑定到该值。注意我使用了两次Display，这通常是一个错误，但它是唯一的工作方式。

<ComboBox SelectedValue="{Binding ElementMap.EdiDataType, Mode=TwoWay}"
                      DisplayMemberPath="Display"
                      SelectedValuePath="Display"
                      ItemsSource="{Binding Source={core:EnumToItemsSource {x:Type edi:EdiDataType}}}" />

格雷格

Answer 15

使用ReactiveUI，我创建了以下备用解决方案。它不是一个优雅的一体化解决方案，但我认为至少它是可读的。

在我的情况下，将enum列表绑定到控件是一种罕见的情况，因此我不需要跨代码库扩展解决方案。但是，通过将EffectStyleLookup.Item更改为Object，可以使代码更通用。我用我的代码测试了它，不需要其他修改。这意味着可以将一个帮助程序类应用于任何enum列表。虽然这会降低其可读性 - ReactiveList<EnumLookupHelper>对它没有很好的响应。

使用以下助手类：

public class EffectStyleLookup
{
    public EffectStyle Item { get; set; }
    public string Display { get; set; }
}

在ViewModel中，转换枚举列表并将其作为属性公开：

public ViewModel : ReactiveObject
{
  private ReactiveList<EffectStyleLookup> _effectStyles;
  public ReactiveList<EffectStyleLookup> EffectStyles
  {
    get { return _effectStyles; }
    set { this.RaiseAndSetIfChanged(ref _effectStyles, value); }
  }

  // See below for more on this
  private EffectStyle _selectedEffectStyle;
  public EffectStyle SelectedEffectStyle
  {
    get { return _selectedEffectStyle; }
    set { this.RaiseAndSetIfChanged(ref _selectedEffectStyle, value); }
  }

  public ViewModel() 
  {
    // Convert a list of enums into a ReactiveList
    var list = (IList<EffectStyle>)Enum.GetValues(typeof(EffectStyle))
      .Select( x => new EffectStyleLookup() { 
        Item = x, 
        Display = x.ToString()
      });

    EffectStyles = new ReactiveList<EffectStyle>( list );
  }
}

在ComboBox中，使用SelectedValuePath属性绑定到原始enum值：

<ComboBox Name="EffectStyle" DisplayMemberPath="Display" SelectedValuePath="Item" />

在视图中，这允许我们将原始enum绑定到ViewModel中的SelectedEffectStyle，但在ToString()中显示ComboBox值：

this.WhenActivated( d =>
{
  d( this.OneWayBind(ViewModel, vm => vm.EffectStyles, v => v.EffectStyle.ItemsSource) );
  d( this.Bind(ViewModel, vm => vm.SelectedEffectStyle, v => v.EffectStyle.SelectedValue) );
});

Answer 16

我正在添加我的评论（遗憾的是，在VB中，这个概念可以很容易地在心跳中复制到C＃），因为我只需要引用它并且不喜欢任何答案，因为它们也是复杂。它不应该是这么困难。

所以我想出了一个更简单的方法。将枚举器绑定到字典。将该字典绑定到Combobox。

我的组合框：

<ComboBox x:Name="cmbRole" VerticalAlignment="Stretch" IsEditable="False" Padding="2" 
    Margin="0" FontSize="11" HorizontalAlignment="Stretch" TabIndex="104" 
    SelectedValuePath="Key" DisplayMemberPath="Value" />

我的代码隐藏。希望这可以帮助其他人。

Dim tDict As New Dictionary(Of Integer, String)
Dim types = [Enum].GetValues(GetType(Helper.Enumerators.AllowedType))
For Each x As Helper.Enumerators.AllowedType In types
    Dim z = x.ToString()
    Dim y = CInt(x)
    tDict.Add(y, z)
Next

cmbRole.ClearValue(ItemsControl.ItemsSourceProperty)
cmbRole.ItemsSource = tDict

Answer 17

Nick的解决方案可以进一步简化，没有什么花哨的地方，您只需要一个转换器即可。

[ValueConversion(typeof(Enum), typeof(IEnumerable<Enum>))]
public class EnumToCollectionConverter : MarkupExtension, IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        var r = Enum.GetValues(value.GetType());
        return r;
    }
    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return null;
    }
    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        return this;
    }
}

然后，您可以在希望出现组合框的任何地方使用此功能：

<ComboBox ItemsSource="{Binding PagePosition, Converter={converter:EnumToCollectionConverter}, Mode=OneTime}"  SelectedItem="{Binding PagePosition}" />

Answer 18

我不建议直接执行此操作，但希望这可以激发一个好的解决方案。

假设您的枚举是Foo。然后您可以执行以下操作。

public class FooViewModel : ViewModel
{
    private int _fooValue;

    public int FooValue
    {
        get => _fooValue;
        set
        {
            _fooValue = value;
            OnPropertyChange();
            OnPropertyChange(nameof(Foo));
            OnPropertyChange(nameof(FooName));
        }
    }
    public Foo Foo 
    { 
        get => (Foo)FooValue; 
        set 
        { 
            _fooValue = (int)value;
            OnPropertyChange();
            OnPropertyChange(nameof(FooValue));
            OnPropertyChange(nameof(FooName));
        } 
    }
    public string FooName { get => Enum.GetName(typeof(Foo), Foo); }

    public FooViewModel(Foo foo)
    {
        Foo = foo;
    }
}

然后在Window.Load方法中，您可以将所有枚举加载到ObservableCollection<FooViewModel>中，并将其设置为组合框的DataContext。

Answer 19

我只是保持简单。我在ViewModel中创建了带有枚举值的项目列表：

public enum InputsOutputsBoth
{
    Inputs,
    Outputs,
    Both
}

private IList<InputsOutputsBoth> _ioTypes = new List<InputsOutputsBoth>() 
{ 
    InputsOutputsBoth.Both, 
    InputsOutputsBoth.Inputs, 
    InputsOutputsBoth.Outputs 
};

public IEnumerable<InputsOutputsBoth> IoTypes
{
    get { return _ioTypes; }
    set { }
}

private InputsOutputsBoth _selectedIoType;

public InputsOutputsBoth SelectedIoType
{
    get { return _selectedIoType; }
    set
    {
        _selectedIoType = value;
        OnPropertyChanged("SelectedIoType");
        OnSelectionChanged();
    }
}

在我的xaml代码中，我只需要这个：

<ComboBox ItemsSource="{Binding IoTypes}" SelectedItem="{Binding SelectedIoType, Mode=TwoWay}">

Answer 20

<Window.Resources>
        <ObjectDataProvider x:Key="DiaryTypeEnum"
       MethodName="GetValues" ObjectType="{x:Type System:Enum}">
            <ObjectDataProvider.MethodParameters>
                <x:Type TypeName="z:Enums+DiaryType"/>
            </ObjectDataProvider.MethodParameters>
        </ObjectDataProvider>
</Window.Resources>
...
<ComboBox ItemsSource="{Binding Source={StaticResource DiaryTypeEnum}}" SelectedItem="{x:Static z:Enums+DiaryType.Defect}" />

其中 z 其 xmlns:z="clr-namespace:ProjName.Helpers"

我的枚举到静态类

  public static class Enums
    {
        public enum DiaryType
        {
            State,
            Defect,
            Service,
            Other
        }
        public enum OtherEnumOrMethods
        {
           //TODO
        }
    }

如何将枚举绑定到WPF中的组合框控件？

20 个答案: