Enum ComboBox using MarkupExtension

         Quite often I find myself in need of using ComboBoxes together with Enum types instead of an ordinary items collection. More over those Enum values have to be translated using a .resx file to the current language. A complex and simple to use solution was needed. In this example I'll show how to create one using MarkupExtension.
First of all, we create MarkupExtension by deriving from MarkupExtension class. MarkupExtensions are quite useful, especially in situations where we have static data (such as resource file, or enum) and we want to do something with the data and return the outcome. All the heavy lifting will be happening in the MarkupExtension's ProvideValue method which we need to override.

Code Snippet

15. public class EnumValuesExtension : MarkupExtension
16. {
17.     private Type _enumType;
18.     private String _resourceName;    
19.     private bool _addEmptyValue = false;
20.     // Enumeration type
21.     public Type EnumType
22.     {
23.         set { _enumType = value; }
24.     }
25.     // Name of the class of the .resx file        
26.     public String ResourceName
27.     {
28.         set { _resourceName = value; }
29.     }    
30.     // Add empty value flag        
31.     public Boolean AddEmptyValue
32.     {
33.         set { _addEmptyValue = value; }
34.     }
35.     public EnumValuesExtension()
36.     {
37.     }

       Next, I've added these 3 properties, which are pretty self explanatory and decorated with comments, they provide the basis for the data that goes into the extension, and are settable from XAML. It is possible to use the constructor straight in XAML, but it's much more comfortable to do it using these properties, hence the constructor remains parameterless.

Code Snippet

39. public override object ProvideValue(IServiceProvider serviceProvider)
40. {
41.     // Enumeration type not passed through XAML
42.     if (_enumType == null)                        
43.         throw new ArgumentNullException("EnumType (Property not set)");
44.     if (!_enumType.IsEnum)                                  
45.         throw new ArgumentNullException("Property EnumType must be an enum");
46.     // Bindable properties list
47.     List<dynamic> list = new List<dynamic>();        
48.  
49.     if (!String.IsNullOrEmpty(_resourceName))
50.     {
51.         // Name of the resource class
52.         Type type = Type.GetType(_resourceName);  
53.         if (type == null)                
54.             throw new ArgumentException(
55.                 "Resource name should be a fully qualified name");
56.         // We iterate through the Enum values
57.         foreach (var enumName in Enum.GetNames(_enumType))  
58.         {
59.             string translation = string.Empty;
60.             var property = type.GetProperty(enumName,
61.                 BindingFlags.Static |
62.                 BindingFlags.Public |
63.                 BindingFlags.NonPublic);
64.             // If there's not translation for specific Enum value,
65.             // there'll be a message shown instead
66.             if (property == null)                 
67.                 translation = String.Format(
68.                     "Field {0} not found in the resource file {1}",
69.                     enumName,
70.                     _resourceName);
71.             else
72.                 translation = property.GetValue(null, null).ToString();
73.                                                  
74.             list.Add(GetNamed(translation, enumName));                    
75.         }
76.         // Adding empty row
77.         if (_addEmptyValue)                       
78.             list.Add(GetEmpty());
79.         return list;
80.     }
81.     // If there's no resource provided Enum values will be used
82.     // without translation
83.     foreach (var enumName in Enum.GetNames(_enumType))  
84.         list.Add(GetNamed(enumName, enumName));               
85.  
86.     if (_addEmptyValue)                                                  
87.         list.Add(GetEmpty());
88.  
89.     return list;
90. }

       Above code is mostly using reflection to shuffle properties around - get values of the enumeration and their translations. Also using dynamic objects to make a bindable context for our ViewModel to bind to. For that we need last 2 methods.

Code Snippet

92. // Create one item which will fill our ComboBox ItemSource list
93. private dynamic GetNamed(string translation, string enumName)
94. {
95.     // We create a bindable context
96.     dynamic bindableResult = new ExpandoObject();    
97.     // This dynamically created property will be
98.     // bindable from XAML (through DisplayMemberPath or wherever)
99.     bindableResult.Translation = translation;
100.     // We're setting the value, which will be passed to SelectedItem
101.     // of the ComboBox
102.     bindableResult.Enum = enumName;                  
103.     return bindableResult;
104. }
105.  
106. // Create one empty item which will fill our ComboBox ItemSource list
107. private dynamic GetEmpty()
108. {
109.     dynamic bindableResult = new ExpandoObject();
110.     bindableResult.Translation = String.Empty;
111.     bindableResult.Enum = null;
112.     return bindableResult;
113. }

       Finally, we can call this code from XAML, it is worth noting that due to how GetType method works we will need a fully qualified path to the resource class. In parameters below we can see properties being set, EnumType to the Type of the enum which is going to fill the Combo, and ResourceName to the fully qualified name of the class (the name of the project/module, in this case "Mod.Ule" is additionally added after the comma). SelectedType is a property in the ViewModel of the same type as the enum passed into the extension, and it is all we need in our VM to make this work. This mechanisms works with DataTemplates as well, all you'd need to do is bind to Translation instead of using DisplayMemberPath.

Code Snippet

42. <ComboBox Height="30" Width="100" VerticalAlignment="Top"
43. SelectedValuePath="Enum" DisplayMemberPath="Translation"
44. ItemsSource="{Binding Source={Extensions:ValuesEnum
45. EnumType=Extensions:Types,
46. ResourceName='Mod.Ule.Resources.Strings.Enums.Resource1,Mod.Ule'}}"
47. SelectedValue="{Binding SelectedType}"/>