ASP.NET MVC 3: DefaultModelBinder с наследованием/полиморфизмом

Я пытался сделать что-то подобное раньше, и я пришел к выводу, что нет ничего встроенного, что справится с этим.

Вариант, который я выбрал, состоял в том, чтобы создать свою собственную привязку модели (хотя и унаследованную от по умолчанию, поэтому кода не так уж много). Он искал значение обратного сообщения с именем типа, называемого xxxConcreteType, где xxx был другим типом, к которому он был привязан. Это означает, что поле должно быть отправлено обратно со значением типа, который вы пытаетесь связать; в этом случае OrderConcreteType со значением OrderBottling или OrderFinishing.

Другой альтернативой является использование UpdateModel или TryUpdateModel и исключение параметра из вашего метода. Вам нужно будет определить, какой тип модели вы обновляете, прежде чем вызывать это (либо с помощью параметра, либо иным образом) и заранее создать экземпляр класса, после чего вы можете использовать любой метод для его заполнения.

Редактировать:

Вот код..

public class AbstractBindAttribute : CustomModelBinderAttribute
{
    public string ConcreteTypeParameter { get; set; }

    public override IModelBinder GetBinder()
    {
        return new AbstractModelBinder(ConcreteTypeParameter);
    }

    private class AbstractModelBinder : DefaultModelBinder
    {
        private readonly string concreteTypeParameterName;

        public AbstractModelBinder(string concreteTypeParameterName)
        {
            this.concreteTypeParameterName = concreteTypeParameterName;
        }

        protected override object CreateModel(ControllerContext controllerContext, ModelBindingContext bindingContext, Type modelType)
        {
            var concreteTypeValue = bindingContext.ValueProvider.GetValue(concreteTypeParameterName);

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

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

            if (concreteType == null)
                throw new Exception("Cannot create abstract model");

            if (!concreteType.IsSubclassOf(modelType))
                throw new Exception("Incorrect model type specified");

            var concreteInstance = Activator.CreateInstance(concreteType);

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

            return concreteInstance;
        }
    }
}

Измените метод действия, чтобы он выглядел следующим образом:

public ActionResult Create([AbstractBind(ConcreteTypeParameter = "orderType")] Order order) { /* implementation ommited */ }

Вам нужно будет указать следующее:

@Html.Hidden("orderType, "Namespace.xxx.OrderBottling")

Вы можете создать пользовательский ModelBinder, который работает, когда ваше действие принимает определенный тип, и может создавать объект любого типа, который вы хотите вернуть. Метод CreateModel() принимает ControllerContext и ModelBindingContext, которые предоставляют вам доступ к параметрам, передаваемым маршрутом, строкой запроса URL и сообщением, которые вы можете использовать для заполнения вашего объекта значениями. Реализация связывателя модели по умолчанию преобразует значения для свойств с тем же именем, чтобы поместить их в поля объекта.

Здесь я просто проверяю одно из значений, чтобы определить, какой тип создать, а затем вызываю метод DefaultModelBinder.CreateModel(), переключающий тип, который он должен создать, на соответствующий тип.

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
    }
}

Установите его для использования, когда у вас есть параметр Order в ваших действиях, добавив его в Application_Start() в Global.asax.cs:

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

Вы также можете создать универсальный ModelBinder, который работает для всех ваших абстрактных моделей. Мое решение требует, чтобы вы добавили в представление скрытое поле под названием «ModelTypeName» со значением, равным имени конкретного типа, который вы хотите. Однако должна быть возможность сделать эту вещь умнее и выбрать конкретный тип, сопоставив свойства типа с полями в представлении.

В вашем Global.asax.cs Application_Start():

ModelBinders.Binders.DefaultBinder = new 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);
    }
}

Мое решение этой проблемы поддерживает сложные модели, которые могут содержать другие абстрактные классы, множественное наследование, коллекции или общие классы.

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);
        }
    }
}

Как видите, вам нужно добавить поле (с именем Type), которое содержит информацию о том, какой конкретный класс, наследующий от абстрактного класса, должен быть создан. Например, классы: class abstract Content, class TextContent, Content должен иметь тип, установленный на "TextContent". Не забудьте переключить связыватель модели по умолчанию в global.asax:

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

Для получения дополнительной информации и примера проекта перейдите по ссылке.

Измените строку:

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

К этому:

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

Это наивная реализация, которая проверяет каждую сборку на тип. Я уверен, что есть более умные способы сделать это, но это работает достаточно хорошо.