How to Display Friendly Names for Enumerations in C#?

An Enumeration (or enum) is a data type that includes a set of named values called elements or members. The enumerator names are usually identifiers that behave as constants in the language.

 

Sometimes you might need to loop on the elements of a particular enum and print its element names, however as you know by the language constraints, the enum element names must follow the naming convention, you cannot include spaces or other special characters. Therefore printing the elements will lead to printing the defined non-friendly elements names.

 

In this article, I will be explaining and showing to you by a code sample how you can define and display friendly names for enumeration elements using the Description annotation.

Also I will be explaining a great way to blend the extension methods feature to write an easy-to-use extension method to get a generic enum’s description property’s value and return it to the caller process.

Let’s say we have the below ColorsEnum enumeration type defined in C#:

 public enum ColorsEnum
 {
       BlanchedAlmond = 1,
       DarkSeaGreen = 2,
       DeepSkyBlue = 3,
       RosyBrown = 4
 }

To print the enumeration elements names, we will iterate over the names of the Enumeration type, append each name to a string builder and then display it on a message box, see the below code snippet:

var stringBuilder = new StringBuilder();

 foreach (string colorEnum in Enum.GetNames(typeof(ColorsEnum)))
 {
        stringBuilder.AppendLine(colorEnum);
 }

 MessageBox.Show(this, stringBuilder.ToString(), "Enumeration None Friendly Names");

The result of executing the above code will be displaying the color names, as they are defined in the enumeration type (in their non-friendly format).

Below is the message box that will be shown once we run the above code:

enumeration-nonfriendly-names

The above code resulted in printing out the names, as defined in the ColorsEnum enumeration data type.

As you can note, the names are non-friendly names; that’s it, no spaces between names.

Sometimes we need to print out a given enumeration element name in a user-friendly format, in this case we will need to add an attribute decoration on each of the enumeration names. This attribute comes from the namespace System.ComponentModel.

The below code shows the updated version of the ColorsEnum, having the new Description attribute decoration applied to the enum names:

public enum ColorsEnum
    {
        [Description("-- Blanched Almond --")]
        BlanchedAlmond = 1,
        [Description("-- Dark Sea Green --")]
        DarkSeaGreen = 2,
        [Description("-- Deep Sky Blue --")]
        DeepSkyBlue = 3,
        [Description("-- Rosy Brown --")]
        RosyBrown = 4
    }

The Description attribute decoration is used to define a descriptive name for a give property or event. It can be used with either enum elements or with any user defined data type property or event.

The description decoration is defined under the System.ComponentModel Namespace, which should be imported directly in the code, or included within the project’s default references.

Even though we defined friendly descriptions for each of our enumeration elements, using the normal ToString() method will keep printing non-friendly names.

So, printing the descriptive friendly names that we defined requires an extension method (Please refer to my blog post Extension Methods in .Net to learn more about writing extension methods).

This extension method will use reflection to get an array of the enum’s members, and then from the array’s first element’s member info it will check and return if the member has a Description attribute defined, if that attribute exists, then it will return the Description value, this will be contained within the GenericEnum variable’s ToString() method.

The code below is an extension method that can be used by any enumeration data type:

public static string GetDescription(this Enum GenericEnum)
        {

            Type genericEnumType = GenericEnum.GetType();
            System.Reflection.MemberInfo[] memberInfo = genericEnumType.GetMember(GenericEnum.ToString());

            if ((memberInfo != null && memberInfo.Length > 0))
            {

                dynamic _Attribs = memberInfo[0].GetCustomAttributes(typeof(System.ComponentModel.DescriptionAttribute), false);
                if ((_Attribs != null && _Attribs.Length > 0))
                {
                    return ((System.ComponentModel.DescriptionAttribute)_Attribs[0]).Description;
                }
            }

            return GenericEnum.ToString();
        }
Now that we wrote our extension method, we are ready to use this method with our ColorsEnum datatype.
Therefore, the below code will show the implementation of printing the friendly enumeration names:

StringBuilder stringBuilder = new StringBuilder();

            foreach (ColorsEnum colorEnum in Enum.GetValues(typeof(ColorsEnum)))
            {
                stringBuilder.AppendLine(colorEnum.GetDescription());
            }

            MessageBox.Show(this, stringBuilder.ToString(), "Enumeration Friendly Names");

As you have noticed, we are using the GetDescription method as it is part of the ColorsEnum(This is the power of the extension methods).

The execution result of the above code is illustrated within the below figure:

enumeration-friendly-names
As you can see, we are now able to display the enumeration values in a user-friendly way instead of displaying them as their code names.

Conclusion

An enumeration is a great way to define a set of constant values in a single data type. If you want to display an enum’s element name on your UI directly by calling its ToString() method, it will be displayed as it has been defined. This will give non-friendly look on the UI if the enum’s element name is a compound name.
The description attribute decoration enables adding descriptive information on the enum’s element name, and then an extension method should be defined to read this decoration.

 

In this article, we defined description attribute decorations on an enum and implemented an extension method for enum to read these decorations and get the values from it.

 

I hope that I was able to simplify and explain how to display friendly names of enumerations in C#.

 

Please let me know if you like this article. Try to implement this tutorial and if you need any help just leave me a comment 🙂

Bonus

My spectacular reader! I am dedicating you a breathtakingly beautiful and relaxing classical music: Mozart – Piano Sonata No. 11 in A major, K. 331 – I. Andante grazioso

Happy coding and listening!

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s