Creating a list from ENUM into Model

Question

I got the following model piece of code:

public enum EnumTest
{
  [Description ("Enum Text 1")]
  Value_1 = 1,

  [Description ("Enum Text 2")]
  Value_2 = 2,
}

public List<Fields> listFields = new List<Fields>();

public class Fields
{
  public int Code { get; set;}
  public string Description { get; set;}
}

I got an Enum and I would like to fill my variable CODE with enum value and the variable Description with the same enum description. I looked up a long time and failed to initialize my "ListFields" into its constructor with the enum VALUE/DESCRIPTION.

I already got the enum and the method to get its description.. I found it usefull, so I'll leave it here, maybe it can be useful for someone..

 public static string GetDescription(this Enum value)
 {
     return (from m in value.GetType().GetMember(value.ToString())
             let attr =(DescriptionAttribute)m.GetCustomAttributes(typeof(DescriptionAttribute), false).FirstOrDefault()
             select attr == null ? value.ToString() : attr.Description).FirstOrDefault();
  }

To use this you just need to do something like this:

String xx = Enum.EnumName.GetDescription();

Answer 1

You have to use reflection.

    public static Fields[] GetEnumFields(Type enumType)
    {
        if (enumType == null)
            throw new ArgumentNullException("enumType");
        if (!enumType.IsEnum)
            throw new ArgumentException("Not an enum");

        FieldInfo[] fieldInfos = enumType.GetFields(BindingFlags.Static | BindingFlags.Public);

        Fields[] result = new Fields[fieldInfos.Length];
        for (int i = 0; i < fieldInfos.Length; ++i)
        {
            FieldInfo field = fieldInfos[i];

            int value = (int)field.GetValue(null);

            DescriptionAttribute attrib = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
            string desc = attrib != null ? attrib.Description : field.Name;

            result[i] = new Fields(value, desc);
        }

        return result;
    }

    public class Fields
    {
        private int value;
        private string description;

        public int Value
        {
            get { return this.value; }
        }

        public string Description
        {
            get { return this.description; }
        }

        public Fields(int value, string description)
        {
            this.value = value;
            this.description = description;
        }
    }

To use it is quite simple:

    enum test
    {
        [Description("hello!")]
        ciao,

        www
    }

    static void Main(string[] args)
    {
        foreach (Fields f in GetEnumFields(typeof(test)))
        {
            Console.WriteLine(f.Description);
        }
    }

In my implementation when a descriptionattribute is not found, field name is used.

We must also say that reflection can be slow and rebuilding the entire array when you need it is a waste of time, if you need it often. You can store the array somewhere so you can compute it only once and keep it cached. This of course and as I said, makes sense only if you need this readonly list very often.