How can I convert/store multiple ENUM selections?

Question

I am able to convert an enum to a string with the following code. However, it only stores ONE of the selected values. In the case where TWO values are selected, it is truncated when I store it using NHibernate.

Here is my code:

MyEnum { One, Two, Three, Four, Five }

private static readonly string[] myEnum =
    Enum.GetNames(typeof(MyEnum));
public string MyProperty
{
    get {
        var value = new MyEnum();
        int i = (int)value;
        return i >= 0 && i < myEnum.Length ?
            myEnum[i] : i.ToString(); }
    set { 
        Record.MyProperty= value == 
            null ? null : String.Join(",", value); }
}

Record is just public virtual string MyProperty { get; set; }

Can anyone provide a sample of how I would store, for example in comma-separated form, multiple enum's that are selected (e.g., "One, Two, Five" are selected by the user and all three are stored in the DB)?

UPDATE:

I am trying to do this in the get{}:

foreach (int i in Enum.GetValues(typeof(MyEnum)))
{
    return i >= 0 && i < myEnum.Length ? myEnum[i] : i.ToString();
}

but am getting a not all code paths return a value error.

QUESTION UPDATE:

If I did this with two string's:

part.MyProperty = record.MyProperty;

Using IEnumerable<MyEnum> answer below from @Jamie Ide won't work because I cannot convert string to MyEnum.

How would I write that last part to get the IEnumerable<MyEnum> code from @Jamie Ide in the answer below to work?

Answer 1

As mentioned in my comment, unless it's an absolute requirement to store the enum as a string I'd recommend setting your enum up with the [Flags] attribute and creating a convention to store the enum as an int. Here's what I use (note I'm using FluentNH):

The convention

public class EnumConvention : IUserTypeConvention
{
    public void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)
    {
        // You can use this if you don't want to support nullable enums
        // criteria.Expect(x => x.Property.PropertyType.IsEnum);

        criteria.Expect(x => x.Property.PropertyType.IsEnum ||
            (x.Property.PropertyType.IsGenericType &&
             x.Property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>) &&
             x.Property.PropertyType.GetGenericArguments()[0].IsEnum)
            );
    }

    public void Apply(IPropertyInstance target)
    {
        target.CustomType(target.Property.PropertyType);
    }
}

The enum
Note you have to be careful what you set the values to in order to keep the bitwise comparison working.

// Note I use long to support enough enum values
[Flags]
public enum MyEnum : long
{
    Foo = 1,
    Bar = 1 << 1,
    Baz = 1 << 2
}

You shouldn't have to do anything beyond that, I believe. No need to iterate to set or retrieve, nothing. To test for the presence of a value, you can use the HasFlag() extension method on the enum.

Update

To modify the MvcGrabBag code to support this kind of enum, you'll need to change the GetItemsFromEnum method as follows:

public static IEnumerable<SelectListItem> GetItemsFromEnum<T>(T enumeration = default(T)) where T : struct
{
    FieldInfo[] fields = enumeration.GetType().GetFields(BindingFlags.Public | BindingFlags.Static);

    return from field in fields
                let value = Enum.Parse(enumeration.GetType(), field.Name)
                let descriptionAttributes = field.GetCustomAttributes(typeof(DescriptionAttribute), true)
                select new SelectListItem
                {
                    Text = descriptionAttributes.Length > 0
                                ? ((DescriptionAttribute)descriptionAttributes[0]).Description
                                : field.Name,
                    Value = Convert.ToInt64(value).ToString(),
                    Selected = (Convert.ToInt64(enumeration) & Convert.ToInt64(value)) == Convert.ToInt64(value)
                };
}

Note that I kept it as a generic only because I don't know what other aspects of that toolkit depend on that signature. You can see that it's not necessary, though -- you can remove the <T> and have the signature like public static IEnumerable<SelectListItem> GetItemsFromEnum(Enum enumeration) and it'll work fine.

Note also that this code is using my convention of supporting names derived from the Description attribute. I use this to let my labels be more human-readable. The enum would look like this:

[Flags]
public enum MyEnum : long
{
    [Description("Super duper foo")]
    Foo = 1,
    [Description("Super duper bar")]
    Bar = 1 << 1,
    // With no description attribute it will use the ToString value
    Baz = 1 << 2
}

Answer 2

Here's a quick and dirty solution. In this solution, _myEnumString would be mapped as a private field and stored in the database. As mentioned in the comments, it is possible to store the array as a collection using another table as shown in the answer to this question or in one table as in this question.

    public enum MyEnum { One, Two, Three, Four, Five }

public class MyClass
{
    private string _myEnumString;

    public IEnumerable<MyEnum> MyEnums
    {
        get 
        { 
            return Array.ConvertAll(_myEnumString.Split(','), s => (MyEnum)Enum.Parse(typeof(MyEnum), s));
        }
        set
        {
            _myEnumString = string.Join(",", value.Select(v => v.ToString()));
        }
    }

}

UPDATE

Assuming record.MyProperty and part.MyProperty are both delimited strings of MyEnum names (e.g. "One,Two,Three") then you can map MyProperty and create a read only property to return the collection of MyEnum.

public class MyClass
{
    public string MyProperty { get; set; }

    public IEnumerable<MyEnum> MyEnums
    {
        get 
        { 
            return Array.ConvertAll(MyProperty.Split(','), s => (MyEnum)Enum.Parse(typeof(MyEnum), s));
        }
    }

}