ASP.NET MVC 3: DefaultModelBinder z dziedziczeniem / polimorfizmem

Możesz utworzyć custome ModelBinder, który działa, gdy twoja akcja akceptuje określony typ i może utworzyć obiekt dowolnego typu, który chcesz zwrócić. Metoda CreateModel () pobiera Kontrolercontext i ModelBindingContext, które dają dostęp do parametrów przekazywanych przez route, url querystring i post, których możesz użyć do wypełnienia obiektu wartościami. Domyślna implementacja modelu Binder konwertuje wartości dla właściwości o tej samej nazwie, aby umieścić je w polach obiekt.

To, co robię, to po prostu sprawdzić jedną z wartości, aby określić, jaki typ utworzyć, a następnie wywołać DefaultModelBinder.Metoda CreateModel() przełącza typ, który ma zostać utworzony na odpowiedni typ.

public class OrderModelBinder : DefaultModelBinder
{
    protected override object CreateModel(
        ControllerContext controllerContext,
        ModelBindingContext bindingContext,
        Type modelType)
    {
        // get the parameter OrderTypeId
        ValueProviderResult result;
        result = bindingContext.ValueProvider.GetValue("OrderTypeId");
        if (result == null)
            return null; // OrderTypeId must be specified

        // I'm assuming 1 for Bottling, 2 for Finishing
        if (result.AttemptedValue.Equals("1"))
            return base.CreateModel(controllerContext,
                    bindingContext,
                    typeof(OrderBottling));
        else if (result.AttemptedValue.Equals("2"))
            return base.CreateModel(controllerContext,
                    bindingContext,
                    typeof(OrderFinishing));
        return null; // unknown OrderTypeId
    }
}

Ustaw, aby była używana, gdy masz parametr Order na swoich akcjach, dodając go do Application_Start () w funkcji Global.asax.cs:

ModelBinders.Binders.Add(typeof(Order), new OrderModelBinder());

Możesz również zbudować ogólny ModelBinder, który działa dla wszystkich Twoich abstrakcyjnych modeli. Moje rozwiązanie wymaga dodania ukrytego pola do widoku o nazwie "ModelTypeName" z wartością ustawioną na nazwę konkretnego typu, który chcesz. Jednak powinno być możliwe, aby uczynić to mądrzejszym i wybrać konkretny typ, dopasowując właściwości typu do pól w widoku.

W Twojej globalnej.asax.cs Application_Start ():

ModelBinders.Binders.DefaultBinder = new CustomModelBinder();

CustomModelBinder:

public class CustomModelBinder : DefaultModelBinder 
{
    protected override object CreateModel(ControllerContext controllerContext, ModelBindingContext bindingContext, Type modelType)
    {
        if (modelType.IsAbstract)
        {
            var modelTypeValue = controllerContext.Controller.ValueProvider.GetValue("ModelTypeName");
            if (modelTypeValue == null)
                throw new Exception("View does not contain ModelTypeName");

            var modelTypeName = modelTypeValue.AttemptedValue;

            var type = modelType.Assembly.GetTypes().SingleOrDefault(x => x.IsSubclassOf(modelType) && x.Name == modelTypeName);
            if(type == null)
                throw new Exception("Invalid ModelTypeName");

            var concreteInstance = Activator.CreateInstance(type);

            bindingContext.ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => concreteInstance, type);

            return concreteInstance;

        }

        return base.CreateModel(controllerContext, bindingContext, modelType);
    }
}

Moje rozwiązanie tego problemu obsługuje złożone modele, które mogą zawierać inne klasy abstrakcyjne, wielokrotne dziedziczenie, Kolekcje lub klasy generyczne.

public class EnhancedModelBinder : DefaultModelBinder
{
    protected override object CreateModel(ControllerContext controllerContext, ModelBindingContext bindingContext, Type modelType)
    {
        Type type = modelType;
        if (modelType.IsGenericType)
        {
            Type genericTypeDefinition = modelType.GetGenericTypeDefinition();
            if (genericTypeDefinition == typeof(IDictionary<,>))
            {
                type = typeof(Dictionary<,>).MakeGenericType(modelType.GetGenericArguments());
            }
            else if (((genericTypeDefinition == typeof(IEnumerable<>)) || (genericTypeDefinition == typeof(ICollection<>))) || (genericTypeDefinition == typeof(IList<>)))
            {
                type = typeof(List<>).MakeGenericType(modelType.GetGenericArguments());
            }
            return Activator.CreateInstance(type);            
        }
        else if(modelType.IsAbstract)
        {
            string concreteTypeName = bindingContext.ModelName + ".Type";
            var concreteTypeResult = bindingContext.ValueProvider.GetValue(concreteTypeName);

            if (concreteTypeResult == null)
                throw new Exception("Concrete type for abstract class not specified");

            type = Assembly.GetExecutingAssembly().GetTypes().SingleOrDefault(t => t.IsSubclassOf(modelType) && t.Name == concreteTypeResult.AttemptedValue);

            if (type == null)
                throw new Exception(String.Format("Concrete model type {0} not found", concreteTypeResult.AttemptedValue));

            var instance = Activator.CreateInstance(type);
            bindingContext.ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => instance, type);
            return instance;
        }
        else
        {
            return Activator.CreateInstance(modelType);
        }
    }
}

Jak widzisz musisz dodać pole (o nazwie typu), które zawiera informację jaka konkretna Klasa dziedzicząca z klasy abstrakcyjnej powinna zostać utworzona. Na przykład klasy: class abstract Content, Klasa TextContent , zawartość powinna mieć Typ ustawiony na "TextContent". Pamiętaj, aby zmienić domyślny model binder w global.asax:

protected void Application_Start()
{
    ModelBinders.Binders.DefaultBinder = new EnhancedModelBinder();
    [...]

Aby uzyskać więcej informacji i przykładowy projekt sprawdź link .

Zmień linię:

var concreteType = Assembly.GetExecutingAssembly().GetType(concreteTypeValue.AttemptedValue);

Do tego:

            Type concreteType = null;
            var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
            foreach (var assembly in loadedAssemblies)
            {
                concreteType = assembly.GetType(concreteTypeValue.AttemptedValue);
                if (null != concreteType)
                {
                    break;
                }
            }

Jest to naiwna implementacja, która sprawdza każdy zespół pod kątem typu. Jestem pewien, że są mądrzejsze sposoby, ale to działa wystarczająco dobrze.