Mvc binding issue from json to enum (customexception from int to enum)

i have this problem: i use the json to send data to server. All works fine but the problem is a situation like:

public enum SexType
{
  Male : 0,
  Female : 1
}

class People{
  public SexType Sex {get;set;}
}

That create me the json:

{"Sex" : 0}

When i send back to server, this fill the ModelStateError with this issue: The parameter conversion from type 'System.Int32' to type 'SexType' failed because no type converter can convert between these types.

But i开发者_如何学运维f i wrap the value with ' all work well:

{"Sex" : '0'}

Anyone have the same problem?

Tnx for all!

Yes, I got the same problem. The weird problem is that if you sent back:

{"Sex" : 'Male'}

it would deserialize no problem. To solve the problem, I implemented a custom model binder for enums, leveraging the example found here (slightly modified as there were some errors): http://eliasbland.wordpress.com/2009/08/08/enumeration-model-binder-for-asp-net-mvc/

namespace yournamespace
{
    /// <summary>
    /// Generic Custom Model Binder used to properly interpret int representation of enum types from JSON deserialization, including default values
    /// </summary>
    /// <typeparam name="T">The enum type to apply this Custom Model Binder to</typeparam>
    public class EnumBinder<T> : IModelBinder
    {
        private T DefaultValue { get; set; }

        public EnumBinder(T defaultValue)
        {
            DefaultValue = defaultValue;
        }

        #region IModelBinder Members
        public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            return bindingContext.ValueProvider.GetValue(bindingContext.ModelName) == null ? DefaultValue : GetEnumValue(DefaultValue, bindingContext.ValueProvider.GetValue(bindingContext.ModelName).AttemptedValue);
        }
        #endregion

        public static T GetEnumValue<T>(T defaultValue, string value)
        {
            T enumType = defaultValue;

            if ((!String.IsNullOrEmpty(value)) && (Contains(typeof(T), value)))
                enumType = (T)Enum.Parse(typeof(T), value, true);

            return enumType;
        }

        public static bool Contains(Type enumType, string value)
        {
            return Enum.GetNames(enumType).Contains(value, StringComparer.OrdinalIgnoreCase);
        }
    }
}

and then registering the model binder in global.asax.cs. In your case it would be something like:

ModelBinders.Binders.Add(typeof(SexType), new EnumBinder<SexType>(SexType.Male));

I am not sure if there is a quicker way, but this works great.

The Model binding uses the Enum.Parse() method, which is fairly smart about interpreting strings but does NOT explicitly cast or convert other types into strings, even if system-level facilities exist to do so and even if they're the internal storage type used within the Enum.

Is this the right behavior? Arguably so, since if you don't know enough to convert your Enum values to strings you might not be aware that the right-hand side of the Enum values are not necessarily unique within the Enum, either.

As a matter of personal taste (and this is probably also because I do way too much statistical analysis programming) for sex I generally prefer to define it as a clear boolean value, i.e. instead of differentiating between arbitrary values for 'Male' and 'Female' I use a variable called e.g. IsFemale and set it to true or false. This plays more nicely with json, since it relies on primitive types common to both languages, and requires less typing when you want to use it.