Como vincular RadioButtons a um enum?

Eu tenho um enum como este:

public enum MyLovelyEnum
{
    FirstSelection,
    TheOtherSelection,
    YetAnotherOne
};

Eu tenho uma propriedade no meu DataContext:

public MyLovelyEnum VeryLovelyEnum { get; set; }

E eu tenho três RadioButtons no meu cliente WPF.

<RadioButton Margin="3">First Selection</RadioButton>
<RadioButton Margin="3">The Other Selection</RadioButton>
<RadioButton Margin="3">Yet Another one</RadioButton>

Agora, como vinculo os RadioButtons à propriedade para uma ligação bidirecional adequada?

Você poderia usar um conversor mais genérico

public class EnumBooleanConverter : IValueConverter
{
  #region IValueConverter Members
  public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
  {
    string parameterString = parameter as string;
    if (parameterString == null)
      return DependencyProperty.UnsetValue;

    if (Enum.IsDefined(value.GetType(), value) == false)
      return DependencyProperty.UnsetValue;

    object parameterValue = Enum.Parse(value.GetType(), parameterString);

    return parameterValue.Equals(value);
  }

  public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
  {
    string parameterString = parameter as string;
    if (parameterString == null)
        return DependencyProperty.UnsetValue;

    return Enum.Parse(targetType, parameterString);
  }
  #endregion
}

E na parte XAML você usa:

<Grid>
    <Grid.Resources>
      <l:EnumBooleanConverter x:Key="enumBooleanConverter" />
    </Grid.Resources>
    <StackPanel >
      <RadioButton IsChecked="{Binding Path=VeryLovelyEnum, Converter={StaticResource enumBooleanConverter}, ConverterParameter=FirstSelection}">first selection</RadioButton>
      <RadioButton IsChecked="{Binding Path=VeryLovelyEnum, Converter={StaticResource enumBooleanConverter}, ConverterParameter=TheOtherSelection}">the other selection</RadioButton>
      <RadioButton IsChecked="{Binding Path=VeryLovelyEnum, Converter={StaticResource enumBooleanConverter}, ConverterParameter=YetAnotherOne}">yet another one</RadioButton>
    </StackPanel>
</Grid>

Você pode simplificar ainda mais a resposta aceita. Em vez de digitar as enumerações como seqüências de caracteres no xaml e fazer mais trabalho no conversor do que o necessário, você pode transmitir explicitamente o valor da enumeração, em vez de uma representação de sequência, e, como comentou o CrimsonX, os erros são gerados no momento da compilação, em vez do tempo de execução:

ConverterParameter = {x: local estático: YourEnumType.Enum1}

<StackPanel>
    <StackPanel.Resources>          
        <local:ComparisonConverter x:Key="ComparisonConverter" />          
    </StackPanel.Resources>
    <RadioButton IsChecked="{Binding Path=YourEnumProperty, Converter={StaticResource ComparisonConverter}, ConverterParameter={x:Static local:YourEnumType.Enum1}}" />
    <RadioButton IsChecked="{Binding Path=YourEnumProperty, Converter={StaticResource ComparisonConverter}, ConverterParameter={x:Static local:YourEnumType.Enum2}}" />
</StackPanel>

Em seguida, simplifique o conversor:

public class ComparisonConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        return value?.Equals(parameter);
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        return value?.Equals(true) == true ? parameter : Binding.DoNothing;
    }
}

---

Editar (16 de dez '10):

Agradecemos a anon por sugerir o retorno de Binding.DoNothing em vez de DependencyProperty.UnsetValue.

---

Nota - Vários grupos de RadioButtons no mesmo contêiner (17 de fevereiro de 11):

No xaml, se os botões de opção compartilharem o mesmo contêiner pai, a seleção de um desmarcará todos os outros contidos nesse contêiner (mesmo que estejam vinculados a uma propriedade diferente). Portanto, tente manter o seu RadioButton vinculado a uma propriedade comum agrupada em seu próprio contêiner como um painel de pilha. Nos casos em que seus RadioButtons relacionados não possam compartilhar um único contêiner pai, defina a propriedade GroupName de cada RadioButton como um valor comum para agrupá-los logicamente.

---

Editar (5 de abril de 11):

Caso contrário do ConvertBack simplificado para usar um Operador Ternário.

---

Nota - Tipo de enum aninhado em uma classe (28 de abril de 11):

Se o seu tipo de enumeração estiver aninhado em uma classe (em vez de diretamente no espaço de nomes), você poderá usar a sintaxe '+' para acessar a enumeração no XAML, conforme indicado em uma resposta (não marcada) à pergunta Não é possível encontrar tipo de enum para referência estática no WPF :

ConverterParameter = {x: local estático: YourClass + YourNestedEnumType.Enum1}

Devido a este problema do Microsoft Connect , no entanto, o designer no VS2010 não carregará mais a declaração "Type 'local:YourClass+YourNestedEnumType' was not found.", mas o projeto é compilado e executado com êxito. Obviamente, você pode evitar esse problema se conseguir mover seu tipo de enum diretamente para o espaço para nome.

---

Editar (27 de janeiro de 12):

Se estiver usando sinalizadores Enum, o conversor seria o seguinte:

public class EnumToBooleanConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        return ((Enum)value).HasFlag((Enum)parameter);
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        return value.Equals(true) ? parameter : Binding.DoNothing;
    }
}

---

Editar (7 de maio de 15):

No caso de um Enum Nullable (que não é perguntado na pergunta, mas pode ser necessário em alguns casos, por exemplo, ORM retornando nulo do DB ou sempre que possa fazer sentido que na lógica do programa o valor não seja fornecido), lembre-se de adicionar uma verificação nula inicial no método Convert e retorne o valor bool apropriado, que normalmente é falso (se você não deseja selecionar nenhum botão de opção), como abaixo:

    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        if (value == null) {
            return false; // or return parameter.Equals(YourEnumType.SomeDefaultValue);
        }
        return value.Equals(parameter);
    }

---

Nota - NullReferenceException (10 de outubro de 18):

Atualizado o exemplo para remover a possibilidade de lançar uma NullReferenceException. IsCheckedé um tipo anulável, portanto, retornar Nullable<Boolean>parece uma solução razoável.

Para a resposta EnumToBooleanConverter: em vez de retornar DependencyProperty.UnsetValue, considere retornar Binding.DoNothing para o caso em que o valor do botão de opção IsChecked se torna falso. O primeiro indica um problema (e pode mostrar ao usuário um retângulo vermelho ou indicadores de validação semelhantes), enquanto o último apenas indica que nada deve ser feito, que é o que se deseja nesse caso.

http://msdn.microsoft.com/en-us/library/system.windows.data.ivalueconverter.convertback.aspx http://msdn.microsoft.com/en-us/library/system.windows.data.binding .donothing.aspx

Eu usaria os RadioButtons em um ListBox e vincularia ao SelectedValue.

Este é um tópico mais antigo sobre este tópico, mas a ideia base deve ser a mesma: http://social.msdn.microsoft.com/Forums/en-US/wpf/thread/323d067a-efef-4c9f-8d99-fecf45522395/

Para o UWP, não é tão simples: você deve pular um aro extra para passar um valor de campo como parâmetro.

Exemplo 1

Válido para WPF e UWP.

<MyControl>
    <MyControl.MyProperty>
        <Binding Converter="{StaticResource EnumToBooleanConverter}" Path="AnotherProperty">
            <Binding.ConverterParameter>
                <MyLibrary:MyEnum>Field</MyLibrary:MyEnum>
            </Binding.ConverterParameter>
        </MyControl>
    </MyControl.MyProperty>
</MyControl>

Exemplo 2

Válido para WPF e UWP.

...
<MyLibrary:MyEnum x:Key="MyEnumField">Field</MyLibrary:MyEnum>
...

<MyControl MyProperty="{Binding AnotherProperty, Converter={StaticResource EnumToBooleanConverter}, ConverterParameter={StaticResource MyEnumField}}"/>

Exemplo 3

Válido apenas para o WPF!

<MyControl MyProperty="{Binding AnotherProperty, Converter={StaticResource EnumToBooleanConverter}, ConverterParameter={x:Static MyLibrary:MyEnum.Field}}"/>

UWP não suporta, x:Staticportanto o Exemplo 3 está fora de questão; supondo que você siga o exemplo 1 , o resultado é um código mais detalhado. O exemplo 2 é um pouco melhor, mas ainda não é o ideal.

Solução

public abstract class EnumToBooleanConverter<TEnum> : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, string language)
    {
        var Parameter = parameter as string;

        if (Parameter == null)
            return DependencyProperty.UnsetValue;

        if (Enum.IsDefined(typeof(TEnum), value) == false)
            return DependencyProperty.UnsetValue;

        return Enum.Parse(typeof(TEnum), Parameter).Equals(value);
    }

    public object ConvertBack(object value, Type targetType, object parameter, string language)
    {
        var Parameter = parameter as string;
        return Parameter == null ? DependencyProperty.UnsetValue : Enum.Parse(typeof(TEnum), Parameter);
    }
}

Em seguida, para cada tipo que você deseja oferecer suporte, defina um conversor que contenha o tipo de enumeração.

public class MyEnumToBooleanConverter : EnumToBooleanConverter<MyEnum>
{
    //Nothing to do!
}

O motivo pelo qual ele deve ser encaixotado é que aparentemente não há como referenciar o tipo no ConvertBackmétodo; o boxe cuida disso. Se você seguir um dos dois primeiros exemplos, poderá referenciar o tipo de parâmetro, eliminando a necessidade de herdar de uma classe in a box; se você deseja fazer tudo em uma linha e com o mínimo de detalhamento possível, a última solução é ideal.

O uso se assemelha ao Exemplo 2 , mas é, de fato, menos detalhado.

<MyControl MyProperty="{Binding AnotherProperty, Converter={StaticResource MyEnumToBooleanConverter}, ConverterParameter=Field}"/>

A desvantagem é que você deve definir um conversor para cada tipo que deseja oferecer suporte.

Eu criei uma nova classe para manipular RadioButtons e CheckBoxes a enumerações. Funciona para enumerações sinalizadas (com várias seleções de caixas de seleção) e enumerações não sinalizadas para caixas de seleção de seleção única ou botões de opção. Também não requer nenhum ValueConverters.

Isso pode parecer mais complicado no começo, no entanto, depois que você copia essa classe em seu projeto, está pronto. É genérico e pode ser reutilizado facilmente para qualquer enumeração.

public class EnumSelection<T> : INotifyPropertyChanged where T : struct, IComparable, IFormattable, IConvertible
{
  private T value; // stored value of the Enum
  private bool isFlagged; // Enum uses flags?
  private bool canDeselect; // Can be deselected? (Radio buttons cannot deselect, checkboxes can)
  private T blankValue; // what is considered the "blank" value if it can be deselected?

  public EnumSelection(T value) : this(value, false, default(T)) { }
  public EnumSelection(T value, bool canDeselect) : this(value, canDeselect, default(T)) { }
  public EnumSelection(T value, T blankValue) : this(value, true, blankValue) { }
  public EnumSelection(T value, bool canDeselect, T blankValue)
  {
    if (!typeof(T).IsEnum) throw new ArgumentException($"{nameof(T)} must be an enum type"); // I really wish there was a way to constrain generic types to enums...
    isFlagged = typeof(T).IsDefined(typeof(FlagsAttribute), false);

    this.value = value;
    this.canDeselect = canDeselect;
    this.blankValue = blankValue;
  }

  public T Value
  {
    get { return value; }
    set 
    {
      if (this.value.Equals(value)) return;
      this.value = value;
      OnPropertyChanged();
      OnPropertyChanged("Item[]"); // Notify that the indexer property has changed
    }
  }

  [IndexerName("Item")]
  public bool this[T key]
  {
    get
    {
      int iKey = (int)(object)key;
      return isFlagged ? ((int)(object)value & iKey) == iKey : value.Equals(key);
    }
    set
    {
      if (isFlagged)
      {
        int iValue = (int)(object)this.value;
        int iKey = (int)(object)key;

        if (((iValue & iKey) == iKey) == value) return;

        if (value)
          Value = (T)(object)(iValue | iKey);
        else
          Value = (T)(object)(iValue & ~iKey);
      }
      else
      {
        if (this.value.Equals(key) == value) return;
        if (!value && !canDeselect) return;

        Value = value ? key : blankValue;
      }
    }
  }

  public event PropertyChangedEventHandler PropertyChanged;

  private void OnPropertyChanged([CallerMemberName] string propertyName = "")
  {
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
  }
}

E para saber como usá-lo, digamos que você tenha uma enumeração para executar uma tarefa manual ou automaticamente, e pode ser agendado para qualquer dia da semana e algumas opções opcionais ...

public enum StartTask
{
  Manual,
  Automatic
}

[Flags()]
public enum DayOfWeek
{
  Sunday = 1 << 0,
  Monday = 1 << 1,
  Tuesday = 1 << 2,
  Wednesday = 1 << 3,
  Thursday = 1 << 4,
  Friday = 1 << 5,
  Saturday = 1 << 6
}

public enum AdditionalOptions
{
  None = 0,
  OptionA,
  OptionB
}

Agora, veja como é fácil usar esta classe:

public class MyViewModel : ViewModelBase
{
  public MyViewModel()
  {
    StartUp = new EnumSelection<StartTask>(StartTask.Manual);
    Days = new EnumSelection<DayOfWeek>(default(DayOfWeek));
    Options = new EnumSelection<AdditionalOptions>(AdditionalOptions.None, true, AdditionalOptions.None);
  }

  public EnumSelection<StartTask> StartUp { get; private set; }
  public EnumSelection<DayOfWeek> Days { get; private set; }
  public EnumSelection<AdditionalOptions> Options { get; private set; }
}

E aqui está como é fácil vincular caixas de seleção e botões de opção a esta classe:

<StackPanel Orientation="Vertical">
  <StackPanel Orientation="Horizontal">
    <!-- Using RadioButtons for exactly 1 selection behavior -->
    <RadioButton IsChecked="{Binding StartUp[Manual]}">Manual</RadioButton>
    <RadioButton IsChecked="{Binding StartUp[Automatic]}">Automatic</RadioButton>
  </StackPanel>
  <StackPanel Orientation="Horizontal">
    <!-- Using CheckBoxes for 0 or Many selection behavior -->
    <CheckBox IsChecked="{Binding Days[Sunday]}">Sunday</CheckBox>
    <CheckBox IsChecked="{Binding Days[Monday]}">Monday</CheckBox>
    <CheckBox IsChecked="{Binding Days[Tuesday]}">Tuesday</CheckBox>
    <CheckBox IsChecked="{Binding Days[Wednesday]}">Wednesday</CheckBox>
    <CheckBox IsChecked="{Binding Days[Thursday]}">Thursday</CheckBox>
    <CheckBox IsChecked="{Binding Days[Friday]}">Friday</CheckBox>
    <CheckBox IsChecked="{Binding Days[Saturday]}">Saturday</CheckBox>
  </StackPanel>
  <StackPanel Orientation="Horizontal">
    <!-- Using CheckBoxes for 0 or 1 selection behavior -->
    <CheckBox IsChecked="{Binding Options[OptionA]}">Option A</CheckBox>
    <CheckBox IsChecked="{Binding Options[OptionB]}">Option B</CheckBox>
  </StackPanel>
</StackPanel>

1. Quando a interface do usuário é carregada, o botão de opção "Manual" será selecionado e você poderá alterar sua seleção entre "Manual" ou "Automático", mas cada um deles sempre deve ser selecionado.
2. Todos os dias da semana serão desmarcados, mas qualquer número deles pode ser marcado ou desmarcado.
3. "Opção A" e "Opção B" serão desmarcadas inicialmente. Você pode marcar um ou outro, marcar um desmarcará o outro (semelhante ao RadioButtons), mas agora também pode desmarcar os dois (o que não é possível com o RadioButton do WPF, e é por isso que o CheckBox está sendo usado aqui)

Este trabalho para a caixa de seleção também.

public class EnumToBoolConverter:IValueConverter
{
    private int val;
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        int intParam = (int)parameter;
        val = (int)value;

        return ((intParam & val) != 0);
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        val ^= (int)parameter;
        return Enum.Parse(targetType, val.ToString());
    }
}

Vincular uma única enumeração a várias caixas de seleção.

Baseado no EnumToBooleanConverter de Scott. Notei que o método ConvertBack não funciona no código Enum com sinalizadores.

Eu tentei o seguinte código:

public class EnumHasFlagToBooleanConverter : IValueConverter
    {
        private object _obj;
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            _obj = value;
            return ((Enum)value).HasFlag((Enum)parameter);
        }

        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            if (value.Equals(true))
            {
                if (((Enum)_obj).HasFlag((Enum)parameter))
                {
                    // Do nothing
                    return Binding.DoNothing;
                }
                else
                {
                    int i = (int)_obj;
                    int ii = (int)parameter;
                    int newInt = i+ii;
                    return (NavigationProjectDates)newInt;
                }
            }
            else
            {
                if (((Enum)_obj).HasFlag((Enum)parameter))
                {
                    int i = (int)_obj;
                    int ii = (int)parameter;
                    int newInt = i-ii;
                    return (NavigationProjectDates)newInt;

                }
                else
                {
                    // do nothing
                    return Binding.DoNothing;
                }
            }
        }
    }

A única coisa que não consigo trabalhar é fazer um elenco de intpara, targetTypeentão eu o codifiquei para NavigationProjectDateso enum que eu uso. E targetType == NavigationProjectDates...

---

Edite para um conversor genérico de Flags Enum:

    classe pública FlagsEnumToBooleanConverter: IValueConverter {
        private int _flags = 0;
        objeto público Convert (valor do objeto, Type targetType, parâmetro do objeto, idioma da string) {
            if (value == null) retorna false;
            _flags = valor (int);
            Digite t = value.GetType ();
            objeto o = Enum.ToObject (t, parâmetro);
            return ((Enum) value) .HasFlag ((Enum) o);
        }

        objeto público ConvertBack (valor do objeto, Tipo targetType, parâmetro do objeto, idioma da string)
        {
            if (value? .Equals (true) ?? false) {
                _flags = _flags | parâmetro (int);
            }
            outro {
                _flags = _flags & ~ (int) parâmetro;
            }
            return _flags;
        }
    }

Você pode criar os botões de opção dinamicamente, ListBoxpode ajudá-lo a fazer isso, sem conversores, bastante simples.

As etapas do concreate estão abaixo: crie um ListBox e defina o ItemsSource para o listbox como a enumeração MyLovelyEnume vinculando o SelectedItem do ListBox à VeryLovelyEnumpropriedade Em seguida, os botões de opção para cada ListBoxItem serão criados.

• Etapa 1 : adicione a enumeração aos recursos estáticos para sua Janela, UserControl ou Grade etc.

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

• Etapa 2 : use a caixa de listagem e Control Templatepara preencher cada item dentro como botão de opção

    <ListBox ItemsSource="{Binding Source={StaticResource MyLovelyEnum}}" SelectedItem="{Binding VeryLovelyEnum, Mode=TwoWay}" >
        <ListBox.Resources>
            <Style TargetType="{x:Type ListBoxItem}">
                <Setter Property="Template">
                    <Setter.Value>
                        <ControlTemplate>
                            <RadioButton
                                Content="{TemplateBinding ContentPresenter.Content}"
                                IsChecked="{Binding Path=IsSelected,
                                RelativeSource={RelativeSource TemplatedParent},
                                Mode=TwoWay}" />
                        </ControlTemplate>
                    </Setter.Value>
                </Setter>
            </Style>
        </ListBox.Resources>
    </ListBox>

A vantagem está abaixo: se algum dia sua classe enum mudar, você não precisará atualizar a GUI (arquivo XAML).

Referências: https://brianlagunas.com/a-better-way-to-data-bind-enums-in-wpf/