ASP.NET MVC 3：具有继承/多态性的 DefaultModelBinder

Question

首先，对这篇大文章（我尝试先做一些研究）以及针对同一问题的技术组合（ASP.NET MVC 3、Ninject 和 MvcContrib）表示歉意。

我正在使用 ASP.NET MVC 3 开发一个项目来处理一些客户订单。

简而言之：我有一些继承自抽象类Order的对象，当向我的控制器发出POST请求时，我需要解析它们。如何解析正确的类型？我是否需要重写 DefaultModelBinder 类或者还有其他方法可以做到这一点？有人可以为我提供一些关于如何执行此操作的代码或其他链接吗？任何帮助都会很棒！ 如果帖子令人困惑，我可以做任何更改以使其清晰！

因此，我需要处理的订单有以下继承树：

public abstract partial class Order {

    public Int32 OrderTypeId {get; set; }

    /* rest of the implementation ommited */
}

public class OrderBottling : Order { /* implementation ommited */ }

public class OrderFinishing : Order { /* implementation ommited */ }

这些类都是由实体框架生成的，所以我不会修改它们，因为我需要更新模型（我知道我可以扩展它们）。此外，还会有更多订单，但全部源自 Order。

我有一个通用视图 (Create.aspx) 来创建订单，该视图为每个继承订单调用强类型部分视图（在本例中为 OrderBotttle > 和订单完成）。我在 OrderController 类上为 GET 请求定义了一个 Create() 方法，为 POST 请求定义了其他方法。第二个如下所示：

public class OrderController : Controller
{
    /* rest of the implementation ommited */

    [HttpPost]
    public ActionResult Create(Order order) { /* implementation ommited */ }
}

现在的问题是：当我收到带有表单数据的 POST 请求时，MVC 的默认绑定器尝试实例化一个 Order 对象，这是可以的，因为该方法的类型就是这样。但由于 Order 是抽象的，因此无法实例化，而这正是应该做的。

问题：如何发现视图发送的具体Order类型？

我已经在 Stack Overflow 上搜索过，并在 google 上搜索了很多相关内容（我现在正在研究这个问题大约 3 天！），并找到了一些解决一些类似问题的方法，但我找不到像我真实的问题一样的东西问题。解决此问题的两种选择：

• 重写 ASP.NET MVC DefaultModelBinder 并使用直接注入来发现 Order 的类型；
• 为每个订单创建一个方法（不美观并且维护起来会有问题）。

我没有尝试第二个选项，因为我认为这不是解决问题的正确方法。对于第一个选项，我尝试使用 Ninject 解析订单类型并实例化它。我的 Ninject 模块如下所示：

private class OrdersService : NinjectModule
{
    public override void Load()
    {
        Bind<Order>().To<OrderBottling>();
        Bind<Order>().To<OrderFinishing>();
    }
}

我尝试通过 Ninject 的 Get<>() 方法获取其中一种类型，但它告诉我，解决该问题的方法不止一种。类型。所以，我知道该模块没有得到很好的实现。我也尝试对两种类型实现这样的： Bind().To().WithPropertyInject("OrderTypeId", 2);，但它有同样的问题...实现该模块的正确方法是什么？

我还尝试过使用 MvcContrib Model Binder。我已经这样做了：

[DerivedTypeBinderAware(typeof(OrderBottling))]
[DerivedTypeBinderAware(typeof(OrderFinishing))]
public abstract partial class Order { }

在 Global.asax.cs 上我已经这样做了：

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

    RegisterRoutes(RouteTable.Routes);

    ModelBinders.Binders.Add(typeof(Order), new DerivedTypeModelBinder());
}

但这会引发异常：System.MissingMethodException：无法创建抽象类。因此，我认为活页夹没有或无法解析为正确的类型。

非常非常感谢！

编辑：首先，感谢 Martin 和 Jason 的回答，对于延迟，我们深表歉意！我尝试了两种方法并且都有效！我将 Martin 的答案标记为正确，因为它更灵活并且满足了我项目的一些需求。具体来说，每个请求的 ID 都存储在数据库中，如果我仅在一个位置（数据库或类上）更改 ID，则将它们放在类上可能会破坏软件。马丁的方法在这一点上非常灵活。

@Martin：在我的代码中，我将行更改

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

为，

var concreteType = Assembly.GetAssembly(typeof(Order)).GetType(concreteTypeValue.AttemptedValue);

因为我的类位于另一个项目上（因此，在不同的程序集中）。我分享这个是因为它似乎比仅获取无法解析外部程序集类型的执行程序集更灵活。就我而言，所有订单类都位于同一个程序集中。这不是更好，也不是一个神奇的公式，但我认为分享这个很有趣;)

Answer 1

我之前尝试过做类似的事情，但我得出的结论是，没有内置的东西可以处理这个问题。

我选择的选项是创建自己的模型绑定器（尽管继承自默认模型绑定器，因此代码不多）。它查找名为 xxxConcreteType 的类型名称的回发值，其中 xxx 是它绑定到的另一种类型。这意味着必须将一个字段与您尝试绑定的类型的值一起发回；在本例中，OrderConcreteType 的值为 OrderBotttle 或 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")

Answer 2

您可以创建一个自定义 ModelBinder，该 ModelBinder 在您的操作接受某种类型时运行，并且它可以创建您想要返回的任何类型的对象。 CreateModel() 方法采用 ControllerContext 和 ModelBindingContext，使您可以访问通过路由、url 查询字符串和 post 传递的参数，您可以使用它们来填充值的对象。默认模型绑定器实现会转换同名属性的值，以将它们放入对象的字段中。

我在这里所做的只是检查其中一个值以确定要创建的类型，然后调用 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
    }
}

通过将其添加到 Global.asax.cs 中的 Application_Start() 中，将其设置为在操作上有 Order 参数时使用：

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

Answer 3

您还可以构建适用于所有抽象模型的通用 ModelBinder。我的解决方案要求您向视图中添加一个名为“ModelTypeName”的隐藏字段，并将值设置为所需的具体类型的名称。但是，应该可以使这个东西变得更智能，并通过将类型属性与视图中的字段匹配来选择具体类型。

在 Global.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);
    }
}

Answer 4

我针对该问题的解决方案支持复杂模型，其中可以包含其他抽象类、多重继承、集合或泛型类。

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

正如您所看到的，您必须添加字段（名称为类型），其中包含应创建从抽象类继承的具体类的信息。例如类：类抽象内容、类 TextContent，内容的类型应设置为“TextContent”。
请记住在 global.asax 中切换默认模型绑定器：

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

有关更多信息和示例项目，请检查以下 链接。

Answer 5

更改行：

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

这是一个简单的实现，用于检查每个程序集的类型。我确信有更聪明的方法可以做到这一点，但这已经足够好了。