wpf - How to bind RadioButtons to an enum?

ID : 5673

viewed : 320

Tags : wpfdata-bindingenumsradio-buttonwpf





Top 5 Answer for wpf - How to bind RadioButtons to an enum?

vote vote

97

You can further simplify the accepted answer. Instead of typing out the enums as strings in xaml and doing more work in your converter than needed, you can explicitly pass in the enum value instead of a string representation, and as CrimsonX commented, errors get thrown at compile time rather than runtime:

ConverterParameter={x:Static local: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> 

Then simplify the converter:

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;     } } 

Edit (Dec 16 '10):

Thanks to anon for suggesting returning Binding.DoNothing rather than DependencyProperty.UnsetValue.


Note - Multiple groups of RadioButtons in same container (Feb 17 '11):

In xaml, if radio buttons share the same parent container, then selecting one will de-select all other's within that container (even if they are bound to a different property). So try to keep your RadioButton's that are bound to a common property grouped together in their own container like a stack panel. In cases where your related RadioButtons cannot share a single parent container, then set the GroupName property of each RadioButton to a common value to logically group them.

Edit (Apr 5 '11):

Simplified ConvertBack's if-else to use a Ternary Operator.

Note - Enum type nested in a class (Apr 28 '11):

If your enum type is nested in a class (rather than directly in the namespace), you might be able to use the '+' syntax to access the enum in XAML as stated in a (not marked) answer to the question :

ConverterParameter={x:Static local:YourClass+YourNestedEnumType.Enum1}

Due to this Microsoft Connect Issue, however, the designer in VS2010 will no longer load stating "Type 'local:YourClass+YourNestedEnumType' was not found.", but the project does compile and run successfully. Of course, you can avoid this issue if you are able to move your enum type to the namespace directly.


Edit (Jan 27 '12):

If using Enum flags, the converter would be as follows:
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;     } } 

Edit (May 7 '15):

In case of a Nullable Enum (that is **not** asked in the question, but can be needed in some cases, e.g. ORM returning null from DB or whenever it might make sense that in the program logic the value is not provided), remember to add an initial null check in the Convert Method and return the appropriate bool value, that is typically false (if you don't want any radio button selected), like below:
    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);     } 

Note - NullReferenceException (Oct 10 '18):

Updated the example to remove the possibility of throwing a NullReferenceException. `IsChecked` is a nullable type so returning `Nullable` seems a reasonable solution.
vote vote

84

You could use a more generic converter

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 } 

And in the XAML-Part you use:

<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> 
vote vote

75

For the EnumToBooleanConverter answer: Instead of returning DependencyProperty.UnsetValue consider returning Binding.DoNothing for the case where the radio button IsChecked value becomes false. The former indicates a problem (and might show the user a red rectangle or similar validation indicators) while the latter just indicates that nothing should be done, which is what is wanted in that case.

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

vote vote

69

I would use the RadioButtons in a ListBox, and then bind to the SelectedValue.

This is an older thread about this topic, but the base idea should be the same: http://social.msdn.microsoft.com/Forums/en-US/wpf/thread/323d067a-efef-4c9f-8d99-fecf45522395/

vote vote

51

For UWP, it is not so simple: You must jump through an extra hoop to pass a field value as a parameter.

Example 1

Valid for both WPF and UWP.

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

Example 2

Valid for both WPF and UWP.

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

Example 3

Valid only for WPF!

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

UWP doesn't support x:Static so Example 3 is out of the question; assuming you go with Example 1, the result is more verbose code. Example 2 is slightly better, but still not ideal.

Solution

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);     } } 

Then, for each type you wish to support, define a converter that boxes the enum type.

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

The reason it must be boxed is because there's seemingly no way to reference the type in the ConvertBack method; the boxing takes care of that. If you go with either of the first two examples, you can just reference the parameter type, eliminating the need to inherit from a boxed class; if you wish to do it all in one line and with least verbosity possible, the latter solution is ideal.

Usage resembles Example 2, but is, in fact, less verbose.

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

The downside is you must define a converter for each type you wish to support.

Top 3 video Explaining wpf - How to bind RadioButtons to an enum?







Related QUESTION?