Modellbindung an Enums in ASP.NET MVC 3

HINWEIS: Dieses Problem wurde behoben in MVC 4. Wenn Sie ein Upgrade auf MVC 4 ist eine praktikable option für Ihr Projekt, dann ist alles, was Sie tun müssen, um zu beginnen Modell-Bindung an enums.

Gesagt, hier ist der workaround für MVC 3, wenn Sie es noch brauchen.

Das Problem mit dem Standard-Modell von binder in MVC. Die korrekte integer-Wert macht es zu dem Modell, Bindemittel, sondern das Bindemittel ist nicht codiert, um anzeigen auf den integer-Wert des enum. Es richtig bindet, wenn der Wert der übergeben wird ein string, der den Namen Wert der enum. Das problem mit diesem ist, dass, wenn Sie analysieren ein C# - Objekt in JSON mit der Json() Methode sendet den angegebenen integer-Wert, wie die enum-Wert, nicht den Namen Wert.

Die einfachste und transparenteste Lösung für dieses Problem ist das überschreiben der default modelbinder und schreiben eigene Logik zu fixieren, wie es bindet enums.

1. Erstellen Sie eine neue Klasse, wie so.

   namespace CustomModelBinders
   {
       ///<summary>
       ///Override for DefaultModelBinder in order to implement fixes to its behavior.
       ///This model binder inherits from the default model binder. All this does is override the default one,
       ///check if the property is an enum, if so then use custom binding logic to correctly map the enum. If not,
       ///we simply invoke the base model binder (DefaultModelBinder) and let it continue binding as normal.
       ///</summary>
       public class EnumModelBinder : DefaultModelBinder
       {
           ///<summary>
           ///Fix for the default model binder's failure to decode enum types when binding to JSON.
           ///</summary>
           protected override object GetPropertyValue(ControllerContext controllerContext, ModelBindingContext bindingContext,
               PropertyDescriptor propertyDescriptor, IModelBinder propertyBinder)
           {
               var propertyType = propertyDescriptor.PropertyType;
               if (propertyType.IsEnum)
               {
                   var providerValue = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
                   if (null != providerValue)
                   {
                       var value = providerValue.RawValue;
                       if (null != value)
                       {
                           var valueType = value.GetType();
                           if (!valueType.IsEnum)
                           {
                               return Enum.ToObject(propertyType, value);
                           }
                       }
                   }
               }
               return base.GetPropertyValue(controllerContext, bindingContext, propertyDescriptor, propertyBinder);
           }
       }
   }

2. Dann registrieren Sie sich einfach in Ihr Global.asax-Datei.

   protected override void OnApplicationStarted()
   {
       base.OnApplicationStarted();
   
       AreaRegistration.RegisterAllAreas();
       RegisterRoutes(RouteTable.Routes);
   
       //Register your new model binder
       ModelBinders.Binders.DefaultBinder = new EnumModelBinder();
   }

Das ist es. Enumerationen, werden nun korrekt gebunden auf JSON-Objekten.

http://www.codetunnel.com/how-to-bind-to-enums-on-json-objects-in-aspnet-mvc-3

InformationsquelleAutor der Antwort Chev

Ok, Jungs. Ich habe mir ein paar Möglichkeiten, dies zu tun, weil ich müde war, zu schreiben, blöde Arbeit, um in der Vergangenheit diesen Mangel in der .Net-framework. Basierend auf ein paar threads, die ich zusammengestellt haben, die folgende Lösung.

Haftungsausschluss ist dies nicht eine völlig automatisierte Lösung, so dass es nicht Arbeit für alle. Angesichts meiner Implementierung funktioniert es. Vielleicht ist mein Weg wird helfen, jemand anderes design, etwas, das funktioniert für Sie.

Ersten, erstellte ich eine enum-Respository heruntergeladen werden. Enumerationen, die nicht hier wohnen, aber würden Sie brauchen, um sichtbar zu werden aus dem repository.

Im repository, ich habe eine Klasse und eine öffentliche statische Eigenschaft stellen Sie eine Liste von enum-Typen.

namespace MyApp.Enums
{
    public enum ATS_Tabs { TabOne = 0, TabTwo = 1, TabThree = 2, TabFour = 3, TabFive = 4 };

    public class ModelEnums
    {
        public static IEnumerable<Type> Types
        {
            get
            {
                List<Type> Types = new List<Type>();
                Types.Add(typeof(ATS_Tabs));
                return Types;
            }
        }
    }
}

Als Nächstes habe ich ein Modell entwickelt, binder und implementiert das interface IModelBinder (ref. kdawg Kommentar und link).

namespace MyApp.CustomModelBinders
{
    public class EnumModelBinder : IModelBinder
    {
        public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            ValueProviderResult valueResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
            ModelState modelState = new ModelState { Value = valueResult };
            object actualValue = null;

            try
            {
                return Enum.ToObject(Type.GetType(bindingContext.ModelType.AssemblyQualifiedName), Convert.ToInt32(valueResult.AttemptedValue));
            }
            catch (FormatException e)
            {
                modelState.Errors.Add(e);
            }

            bindingContext.ModelState.Add(bindingContext.ModelName, modelState);
            return actualValue;
        }
    }
}

Könnte es helfen, fügen Sie einige code, um sicherzustellen, dass die Konvertierung von valueResult.AttemptedValue nicht scheitern.

Weiter, ich schlang Sie durch die Liste der enum-Typen, die ich oben erstellt und Hinzugefügt, model-Mappen, die für Sie (...im Allgemeinen.asax.cs).

    protected void Application_Start()
    {
        AreaRegistration.RegisterAllAreas();

        foreach (Type type in ModelEnums.Types)
        {
            ModelBinders.Binders.Add(type, new EnumModelBinder());
        }

        RegisterGlobalFilters(GlobalFilters.Filters);
        RegisterRoutes(RouteTable.Routes);
    }

Ich zugeben, das es nicht der intuitivste Weg, aber es funktioniert Super für mich. Fühlen Sie sich frei, zu lassen mich wissen, wenn ich kann diese optimieren.

InformationsquelleAutor der Antwort Difinity