How do you make an 'enum' that has data tied to it?

Question

I have a Vote class and one of the properties it can have is a vote type. Such as unanimous, a 3/4 vote, a simply majority, etc. Each type needs to have a string associated with it which will describe the vote type (like "A simply majority requires 51% to pass" etc.). I need to pass these vote types/description in with my view model to my view and then I can make my drop down list with it.

Then, when the form that creates the vote is submitted I just need to bind the vote type (without description) to the Vote model (which is part of the view model).

I've only been using C# for a short time and I don't quite understand how the enums work in it. Perhaps enum is not the way to go about this.

public class VoteViewModel
{
    public VoteViewModel()
    {
        Vote = new Vote();
    }

    public Vote Vote { get; set; }
    public int EligibleVoters { get; set; }
}

And this is where I'll be putting the drop down.

<section class="vote-type">
    <select name="">
        <option value="">Select Vote Type</option>
    </select>
    <section class="vote-type-info">
        <p class="vote-rules">To pass this vote, at least 51% of Eligible Voters must vote to approve it.</p>
    </section>
</section>

Answer 1

Please notice I'm only showing for strings for it could be any type. In each case I mention how to extend it for more values if possible.

---

Using the enum as a key

You can use your enum type as a key for a dictionary (you want to be unique, so make it static and readonly in some helper class):

private static readonly Dictionary<MyEnum, string> _dict =
{
    //Using dictionary initialization
    {MyEnum.MyValue, "The text for MyValue"},
    {MyEnum.MyOtherValue, "Some other text"},
    {MyEnum.YetAnotherValue, "Something else"}
}

public static readonly Dictionary<MyEnum, string> Dict
{
    get
    {
        return _dict;
    }
}

And access the associated value:

string text = Dict[MyEnum.MyValue];

Or with:

string text;
if (Dict.TryGetValue(MyEnum.MyValue, out text))
{
    //It has the value
}
else
{
    //It doesn't have the value
}

This way you can access a string that is associated with the enum value. Then you can expose your Dictionary so that you can read the corresponding values.

You will need a complex type for storing more than one value. Just use your custom type isntead of string. Or if available you can use Tuples.

Accesing the Dictionary may mean an extra annoyance and hopefully it will not mean a threading problem too.

---

Enum.GetName

You can use Enum.GetName to read the name of the values of your enum:

string text = Enum.GetName(MyEnum.MyValue);
//text will have the text "MyValue"

//or
var some = MyEnum.MyValue;
string text = Enum.GetName(some);

Note: ToString() should work too.

Sadly, this will not work for something else than the string.

Also it has the drawback that you cannot put any text there (it has to be a valid identifier).

---

Custom Attributes

You will have to declare an attribute type:

[AttributeUsage(AttributeTargets.Field)]
public class EnumValueAttribute : System.Attribute 
{
    public readonly string _value;
    public string Value
    {
        get
        {
            return _value;
        }
    }
    public EnumValueAttribute(string value)  // value is a positional parameter
    {
        //beware: value can be null...
        // ...but we don't want to throw exceptions here
        _value = value;
    }
}

Now you apply the attribute to your enum:

public enum MyEnum
{
    [EnumValue("The text for MyValue")]
    MyValue = 1,
    [EnumValue("Some other text")]
    MyOtherValue = 2,
    [EnumValue("Something else")]
    YetAnotherValue = 3
}

Lastly you will need to read the attribute back:

public static string GetValue(MyEnum enumValue)
{
    FieldInfo fieldInfo = typeof(MyEnum).GetField(enumValue.ToString());
    if (!ReferenceEquals(fieldInfo, null))
    {
        object[] attributes = fieldInfo.GetCustomAttributes(typeof(EnumValueAttribute), true);
        if (!ReferenceEquals(attributes, null) && attributes.Length > 0)
        {
            return ((EnumValueAttribute)attributes[0]).Value;
        }
    }
    //Not valid value or it didn't have the attribute
    return null;
}

Now you can call it:

string text1 = GetValue(MyEnum.MyValue);
//text1 will have the text "MyValue"
//or
var some = MyEnum.MyValue;
string text2 = GetValue(some);

You can add more fields to your attribute class and use them to pass any other value you may need.

But this requires reflexion, and it may not be available if you are running in a sandbox. Also it will retrieve the attributes each time, creating some short lived objects in the proccess.

---

Emulate Enum

You can emulate an enum with a sealed class that has no public constructor and exposes static readonly instances of itself:

public sealed class MyEnumEmu
{
    private static readonly string myValue = new MyEnumEmu("The text for MyValue");
    private static readonly string myOtherValue = new MyEnumEmu("Some other text");
    private static readonly string yetAnotherValue = new MyEnumEmu("Something else");

    public static MyEnumEmu MyValue
    {
        get
        {
            return myValue;
        }
    }

    public static MyEnumEmu MyOtherValue 
    {
        get
        {
            return myOtherValue;
        }
    }

    public static MyEnumEmu YetAnotherValue
    {
        get
        {
            return yetAnotherValue;
        }
    }

    private string _value;

    private MyEnumEmu(string value)
    {
        //Really, we are in control of the callers of this constructor...
        //... but, just for good measure:
        if (value == null)
        {
            throw new ArgumentNullException("value");
        }
        else
        {
            _value = value;
        }
    }

    public string Value
    {
        get
        {
            return _value;
        }
    }
}

Use it as always:

var some = MyEnumEmu.MyValue;

And access the associated value:

string text = MyEnumEmu.MyValue.Value;
//text will have the text "MyValue"
//or
string text = some.Value;

This is the more flexible of all, you can either use a complex type instead of string or add extra fields for passing more than a single value.

But... it is not really an enum.

Answer 2

You could create a "constant" dictionary (or rather readonly static, since you can't create a constant dictionary) around your Enum.

public enum VoteType { Unanimous = 1, SimpleMajority = 2, ... }

public static readonly Dictionary<VoteType, string> VoteDescriptions = new Dictionary<VoteType, string>
{
    { VoteType.Unanimous, "Unanimous description" },
    { VoteType.SimpleMajority, "Simple majority" },
    ...
};

Answer 3

public class Vote()
{
     public VoteType VoteSelectType { get; set; }
}

public enum VoteType
{
    [Display(Name = "Enter Text Here")]
    unanimous = 1,
    [Display(Name = "Enter Text Here")]
    threequatervote = 2,
    [Display(Name = "Enter Text Here")]
    simplymajority = 3
}

Goto here this is pretty much your solution How do I populate a dropdownlist with enum values?

Answer 4

I have used this before, it is really handy.

http://www.codeproject.com/Articles/13821/Adding-Descriptions-to-your-Enumerations

In short what it lets you do is:

public enum MyColors{
   [Description("The Color of my skin")]
   White,
   [Description("Bulls like this color")]
   Red,
   [Description("The color of slime")]
   Green
}

and then get the description back by simply calling:

String desc = GetDescription(MyColor.Green);

It does use reflection though, so there is a tradeoff between simplicity and a slight performance hit. Most of the time I'd take the performance hit...

Answer 5

You can use enums if you want but you need to decide how to make the link between the enum value and what you want to display. For example, an enum value of SimpleMajority you would want displayed as "Simple Majority". One way to do this is using the Description attribute and a helper class as described here.

However, you might find it easier to set up a lightweight collection class to store vote type values and their description. This could be as simple as a Dictionary<int, string> You will probably find this a more straightforward approach.

Answer 6

Since you have the type and description I'll better suggest you to create a class that wraps up both instead of enum. The advantage is you can reduce more work and it's very flexible.

public class VoteType
{
   public string Name{ get; set; }
   public string Description{ get; set; }
}

Now your Vote class will have reference to this VoteType.

public class Vote
{
   ...
   public VoteType Type{ get; set; }
}

In your VoteViewModel you better have a class that contains all the VoteTypes.

public class VoteViewModel
{
   ...
   public IEnumerable<SelectListItem> VoteTypes{ get; set; }
}

Now you can easily bind the VoteTypes in a dropdownlist.

@model VoteViewModel

@Html.DropDiwnListFor(m => m.VoteTypes,...)