Vincular uma propriedade enum a uma ComboBox no WPF

Como exemplo, pegue o seguinte código:

public enum ExampleEnum { FooBar, BarFoo }

public class ExampleClass : INotifyPropertyChanged
{
    private ExampleEnum example;

    public ExampleEnum ExampleProperty 
    { get { return example; } { /* set and notify */; } }
}

Eu quero um para vincular a propriedade ExampleProperty a um ComboBox, para que ele mostre as opções "FooBar" e "BarFoo" e funcione no modo TwoWay. Idealmente, quero que minha definição ComboBox seja algo como isto:

<ComboBox ItemsSource="What goes here?" SelectedItem="{Binding Path=ExampleProperty}" />

Atualmente, tenho manipuladores para os eventos ComboBox.SelectionChanged e ExampleClass.PropertyChanged instalados na minha janela onde faço a ligação manualmente.

Existe alguma maneira canônica ou melhor? Você usaria normalmente os conversores e como preencheria a caixa de combinação com os valores certos? Eu nem quero começar o i18n agora.

Editar

Então, uma pergunta foi respondida: Como preencho a ComboBox com os valores corretos.

Recupere valores de Enum como uma lista de seqüências de caracteres por meio de um ObjectDataProvider do método estático Enum.GetValues:

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

Isso eu posso usar como uma ItemsSource para minha ComboBox:

<ComboBox ItemsSource="{Binding Source={StaticResource ExampleEnumValues}}"/>

Você pode criar uma extensão de marcação personalizada.

Exemplo de uso:

enum Status
{
    [Description("Available.")]
    Available,
    [Description("Not here right now.")]
    Away,
    [Description("I don't have time right now.")]
    Busy
}

Na parte superior do seu XAML:

    xmlns:my="clr-namespace:namespace_to_enumeration_extension_class

e depois...

<ComboBox 
    ItemsSource="{Binding Source={my:Enumeration {x:Type my:Status}}}" 
    DisplayMemberPath="Description" 
    SelectedValue="{Binding CurrentStatus}"  
    SelectedValuePath="Value"  /> 

E a implementação ...

public class EnumerationExtension : MarkupExtension
  {
    private Type _enumType;


    public EnumerationExtension(Type enumType)
    {
      if (enumType == null)
        throw new ArgumentNullException("enumType");

      EnumType = enumType;
    }

    public Type EnumType
    {
      get { return _enumType; }
      private set
      {
        if (_enumType == value)
          return;

        var enumType = Nullable.GetUnderlyingType(value) ?? value;

        if (enumType.IsEnum == false)
          throw new ArgumentException("Type must be an Enum.");

        _enumType = value;
      }
    }

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
      var enumValues = Enum.GetValues(EnumType);

      return (
        from object enumValue in enumValues
        select new EnumerationMember{
          Value = enumValue,
          Description = GetDescription(enumValue)
        }).ToArray();
    }

    private string GetDescription(object enumValue)
    {
      var descriptionAttribute = EnumType
        .GetField(enumValue.ToString())
        .GetCustomAttributes(typeof (DescriptionAttribute), false)
        .FirstOrDefault() as DescriptionAttribute;


      return descriptionAttribute != null
        ? descriptionAttribute.Description
        : enumValue.ToString();
    }

    public class EnumerationMember
    {
      public string Description { get; set; }
      public object Value { get; set; }
    }
  }

No modelo de exibição, você pode ter:

public MyEnumType SelectedMyEnumType 
{
    get { return _selectedMyEnumType; }
    set { 
            _selectedMyEnumType = value;
            OnPropertyChanged("SelectedMyEnumType");
        }
}

public IEnumerable<MyEnumType> MyEnumTypeValues
{
    get
    {
        return Enum.GetValues(typeof(MyEnumType))
            .Cast<MyEnumType>();
    }
}

No XAML, o ItemSourcevincula MyEnumTypeValuese o SelectedItemvincula SelectedMyEnumType.

<ComboBox SelectedItem="{Binding SelectedMyEnumType}" ItemsSource="{Binding MyEnumTypeValues}"></ComboBox>

Prefiro não usar o nome de enum na interface do usuário. Eu prefiro usar um valor diferente para user ( DisplayMemberPath) e diferente para value (enum neste caso) ( SelectedValuePath). Esses dois valores podem ser compactados KeyValuePaire armazenados no dicionário.

XAML

<ComboBox Name="fooBarComboBox" 
          ItemsSource="{Binding Path=ExampleEnumsWithCaptions}" 
          DisplayMemberPath="Value" 
          SelectedValuePath="Key"
          SelectedValue="{Binding Path=ExampleProperty, Mode=TwoWay}" > 

C #

public Dictionary<ExampleEnum, string> ExampleEnumsWithCaptions { get; } =
    new Dictionary<ExampleEnum, string>()
    {
        {ExampleEnum.FooBar, "Foo Bar"},
        {ExampleEnum.BarFoo, "Reversed Foo Bar"},
        //{ExampleEnum.None, "Hidden in UI"},
    };


private ExampleEnum example;
public ExampleEnum ExampleProperty
{
    get { return example; }
    set { /* set and notify */; }
}

EDIT: Compatível com o padrão MVVM.

Não sei se é possível apenas em XAML, mas tente o seguinte:

Dê um nome à sua ComboBox para que você possa acessá-la no código abaixo: "typesComboBox1"

Agora tente o seguinte

typesComboBox1.ItemsSource = Enum.GetValues(typeof(ExampleEnum));

Com base na resposta aceita, mas agora excluída, fornecida por ageektrapped , criei uma versão reduzida, sem alguns dos recursos mais avançados. Todo o código está incluído aqui para permitir que você copie e cole e não seja bloqueado pelo link-rot.

Eu uso o System.ComponentModel.DescriptionAttributeque realmente se destina a descrições de tempo de design. Se você não gosta de usar esse atributo, pode criar o seu próprio, mas acho que usar esse atributo realmente faz o trabalho. Se você não usar o atributo, o nome usará como padrão o nome do valor da enumeração no código.

public enum ExampleEnum {

  [Description("Foo Bar")]
  FooBar,

  [Description("Bar Foo")]
  BarFoo

}

Aqui está a classe usada como fonte dos itens:

public class EnumItemsSource : Collection<String>, IValueConverter {

  Type type;

  IDictionary<Object, Object> valueToNameMap;

  IDictionary<Object, Object> nameToValueMap;

  public Type Type {
    get { return this.type; }
    set {
      if (!value.IsEnum)
        throw new ArgumentException("Type is not an enum.", "value");
      this.type = value;
      Initialize();
    }
  }

  public Object Convert(Object value, Type targetType, Object parameter, CultureInfo culture) {
    return this.valueToNameMap[value];
  }

  public Object ConvertBack(Object value, Type targetType, Object parameter, CultureInfo culture) {
    return this.nameToValueMap[value];
  }

  void Initialize() {
    this.valueToNameMap = this.type
      .GetFields(BindingFlags.Static | BindingFlags.Public)
      .ToDictionary(fi => fi.GetValue(null), GetDescription);
    this.nameToValueMap = this.valueToNameMap
      .ToDictionary(kvp => kvp.Value, kvp => kvp.Key);
    Clear();
    foreach (String name in this.nameToValueMap.Keys)
      Add(name);
  }

  static Object GetDescription(FieldInfo fieldInfo) {
    var descriptionAttribute =
      (DescriptionAttribute) Attribute.GetCustomAttribute(fieldInfo, typeof(DescriptionAttribute));
    return descriptionAttribute != null ? descriptionAttribute.Description : fieldInfo.Name;
  }

}

Você pode usá-lo no XAML assim:

<Windows.Resources>
  <local:EnumItemsSource
    x:Key="ExampleEnumItemsSource"
    Type="{x:Type local:ExampleEnum}"/>
</Windows.Resources>
<ComboBox
  ItemsSource="{StaticResource ExampleEnumItemsSource}"
  SelectedValue="{Binding ExampleProperty, Converter={StaticResource ExampleEnumItemsSource}}"/> 

Use ObjectDataProvider:

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

e, em seguida, vincule ao recurso estático:

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

Encontre esta solução neste blog

Minha maneira favorita de fazer isso é com um ValueConverterpara que o ItemsSource e o SelectedValue sejam vinculados à mesma propriedade. Isso não requer propriedades adicionais para manter seu ViewModel agradável e limpo.

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

E a definição do conversor:

public static class EnumHelper
{
  public static string Description(this Enum e)
  {
    return (e.GetType()
             .GetField(e.ToString())
             .GetCustomAttributes(typeof(DescriptionAttribute), false)
             .FirstOrDefault() as DescriptionAttribute)?.Description ?? e.ToString();
  }
}

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

Este conversor funcionará com qualquer enumeração. ValueDescriptioné apenas uma classe simples com uma Valuepropriedade e uma Descriptionpropriedade Você poderia facilmente usar um Tuplecom Item1e Item2, ou um KeyValuePaircom Keye em Valuevez de Valor e Descrição ou qualquer outra classe de sua escolha, desde que ela possua um valor de enum e uma descrição de string desse valor de enum.

Aqui está uma solução genérica usando um método auxiliar. Isso também pode manipular uma enumeração de qualquer tipo subjacente (byte, sbyte, uint, long etc.)

Método auxiliar:

static IEnumerable<object> GetEnum<T>() {
    var type    = typeof(T);
    var names   = Enum.GetNames(type);
    var values  = Enum.GetValues(type);
    var pairs   =
        Enumerable.Range(0, names.Length)
        .Select(i => new {
                Name    = names.GetValue(i)
            ,   Value   = values.GetValue(i) })
        .OrderBy(pair => pair.Name);
    return pairs;
}//method

Ver modelo:

public IEnumerable<object> EnumSearchTypes {
    get {
        return GetEnum<SearchTypes>();
    }
}//property

Caixa combo:

<ComboBox
    SelectedValue       ="{Binding SearchType}"
    ItemsSource         ="{Binding EnumSearchTypes}"
    DisplayMemberPath   ="Name"
    SelectedValuePath   ="Value"
/>

você pode considerar algo assim:

1. defina um estilo para o bloco de texto ou qualquer outro controle que você deseja usar para exibir sua enumeração:

   <Style x:Key="enumStyle" TargetType="{x:Type TextBlock}">
       <Setter Property="Text" Value="&lt;NULL&gt;"/>
       <Style.Triggers>
           <Trigger Property="Tag">
               <Trigger.Value>
                   <proj:YourEnum>Value1<proj:YourEnum>
               </Trigger.Value>
               <Setter Property="Text" Value="{DynamicResource yourFriendlyValue1}"/>
           </Trigger>
           <!-- add more triggers here to reflect your enum -->
       </Style.Triggers>
   </Style>

2. defina seu estilo para ComboBoxItem

   <Style TargetType="{x:Type ComboBoxItem}">
       <Setter Property="ContentTemplate">
           <Setter.Value>
               <DataTemplate>
                   <TextBlock Tag="{Binding}" Style="{StaticResource enumStyle}"/>
               </DataTemplate>
           </Setter.Value>
       </Setter>
   </Style>

3. adicione uma caixa de combinação e carregue-a com seus valores de enumeração:

   <ComboBox SelectedValue="{Binding Path=your property goes here}" SelectedValuePath="Content">
       <ComboBox.Items>
           <ComboBoxItem>
               <proj:YourEnum>Value1</proj:YourEnum>
           </ComboBoxItem>
       </ComboBox.Items>
   </ComboBox>

se sua enumeração for grande, é claro que você pode fazer o mesmo no código, poupando muita digitação. Eu gosto dessa abordagem, uma vez que facilita a localização - você define todos os modelos uma vez e depois atualiza apenas seus arquivos de recursos de string.

Se você estiver usando um MVVM, com base na resposta @rudigrobler, faça o seguinte:

Adicione a seguinte propriedade à classe ViewModel

public Array ExampleEnumValues => Enum.GetValues(typeof(ExampleEnum));

Em seguida, no XAML, faça o seguinte:

<ComboBox ItemsSource="{Binding ExampleEnumValues}" ... />

Esta é uma DevExpressresposta específica com base na resposta mais votada por Gregor S.(atualmente ela possui 128 votos).

Isso significa que podemos manter o estilo consistente em todo o aplicativo:

Infelizmente, a resposta original não funciona com um ComboBoxEdit DevExpress sem algumas modificações.

Primeiro, o XAML para ComboBoxEdit:

<dxe:ComboBoxEdit ItemsSource="{Binding Source={xamlExtensions:XamlExtensionEnumDropdown {x:myEnum:EnumFilter}}}"
    SelectedItem="{Binding BrokerOrderBookingFilterSelected, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
    DisplayMember="Description"
    MinWidth="144" Margin="5" 
    HorizontalAlignment="Left"
    IsTextEditable="False"
    ValidateOnTextInput="False"
    AutoComplete="False"
    IncrementalFiltering="True"
    FilterCondition="Like"
    ImmediatePopup="True"/>

Desnecessário dizer que você precisará apontar xamlExtensionspara o espaço para nome que contém a classe de extensão XAML (que é definida abaixo):

xmlns:xamlExtensions="clr-namespace:XamlExtensions"

E temos que apontar myEnumpara o espaço para nome que contém a enumeração:

xmlns:myEnum="clr-namespace:MyNamespace"

Então, o enum:

namespace MyNamespace
{
    public enum EnumFilter
    {
        [Description("Free as a bird")]
        Free = 0,

        [Description("I'm Somewhat Busy")]
        SomewhatBusy = 1,

        [Description("I'm Really Busy")]
        ReallyBusy = 2
    }
}

O problema com o XAML é que não podemos usá-lo SelectedItemValue, pois isso gera um erro, pois o setter é inacessível (um pouco de supervisão de sua parte DevExpress). Portanto, temos que modificar nosso ViewModelpara obter o valor diretamente do objeto:

private EnumFilter _filterSelected = EnumFilter.All;
public object FilterSelected
{
    get
    {
        return (EnumFilter)_filterSelected;
    }
    set
    {
        var x = (XamlExtensionEnumDropdown.EnumerationMember)value;
        if (x != null)
        {
            _filterSelected = (EnumFilter)x.Value;
        }
        OnPropertyChanged("FilterSelected");
    }
}

Para completar, eis a extensão XAML da resposta original (levemente renomeada):

namespace XamlExtensions
{
    /// <summary>
    ///     Intent: XAML markup extension to add support for enums into any dropdown box, see http://bit.ly/1g70oJy. We can name the items in the
    ///     dropdown box by using the [Description] attribute on the enum values.
    /// </summary>
    public class XamlExtensionEnumDropdown : MarkupExtension
    {
        private Type _enumType;


        public XamlExtensionEnumDropdown(Type enumType)
        {
            if (enumType == null)
            {
                throw new ArgumentNullException("enumType");
            }

            EnumType = enumType;
        }

        public Type EnumType
        {
            get { return _enumType; }
            private set
            {
                if (_enumType == value)
                {
                    return;
                }

                var enumType = Nullable.GetUnderlyingType(value) ?? value;

                if (enumType.IsEnum == false)
                {
                    throw new ArgumentException("Type must be an Enum.");
                }

                _enumType = value;
            }
        }

        public override object ProvideValue(IServiceProvider serviceProvider)
        {
            var enumValues = Enum.GetValues(EnumType);

            return (
                from object enumValue in enumValues
                select new EnumerationMember
                       {
                           Value = enumValue,
                           Description = GetDescription(enumValue)
                       }).ToArray();
        }

        private string GetDescription(object enumValue)
        {
            var descriptionAttribute = EnumType
                .GetField(enumValue.ToString())
                .GetCustomAttributes(typeof (DescriptionAttribute), false)
                .FirstOrDefault() as DescriptionAttribute;


            return descriptionAttribute != null
                ? descriptionAttribute.Description
                : enumValue.ToString();
        }

        #region Nested type: EnumerationMember
        public class EnumerationMember
        {
            public string Description { get; set; }
            public object Value { get; set; }
        }
        #endregion
    }
}

Isenção de responsabilidade: não tenho afiliação com o DevExpress. Telerik também é uma ótima biblioteca.

Tente usar

<ComboBox ItemsSource="{Binding Source={StaticResource ExampleEnumValues}}"
    SelectedValue="{Binding Path=ExampleProperty}" />

Eu criei um projeto CodePlex de código aberto que faz isso. Você pode baixar o pacote NuGet aqui .

<enumComboBox:EnumComboBox EnumType="{x:Type demoApplication:Status}" SelectedValue="{Binding Status}" />