Asp.net mvc 3 在MVC3中使用强类型视图时是否可以进行模型继承？

我的模型中有以下设置：

namespace QuickTest.Models
{
    public class Person
    {
        [Required]
        [Display(Name = "Full name")]
        public string FullName { get; set; }

        [Display(Name = "Address Line 1")]
        public virtual string Address1 { get; set; }
    }
    public class Sender : Person
    {
        [Required]
        public override string Address1 { get; set; }
    }
    public class Receiver : Person
    {
    }
}

在我看来：

@model QuickTest.Models.Person
@{
    ViewBag.Title = "Edit";
}
<script src="@Url.Content("~/Scripts/jquery.validate.min.js")" type="text/javascript"></script>
<script src="@Url.Content("~/Scripts/jquery.validate.unobtrusive.min.js")" type="text/javascript"></script>

@using (Html.BeginForm()) {
    <fieldset>
        <legend>Person</legend>
        <div class="editor-label">
            @Html.LabelFor(model => model.FullName)
        </div>
        <div class="editor-field">
            @Html.EditorFor(model => model.FullName)
            @Html.ValidationMessageFor(model => model.FullName)
        </div>
        <div class="editor-label">
            @Html.LabelFor(model => model.Address1)
        </div>
        <div class="editor-field">
            @Html.EditorFor(model => model.Address1)
            @Html.ValidationMessageFor(model => model.Address1)
        </div>

        <div class="errors">
            @Html.ValidationSummary(true)
        </div>
        <p>
            <input type="submit" value="Save" />
        </p>
    </fieldset>
}

@model QuickTest.Models.Person
@{
ViewBag.Title=“编辑”；
}
@使用（Html.BeginForm（））{
人
@LabelFor（model=>model.FullName）
@EditorFor（model=>model.FullName）
@Html.ValidationMessageFor（model=>model.FullName）
@LabelFor（model=>model.Address1）
@EditorFor（model=>model.Address1）
@Html.ValidationMessageFor（model=>model.Address1）
@Html.ValidationSummary（true）


}

已启用客户端验证。但是，如果我向视图发送Sender类型的对象，客户端验证不会检测到Address1字段是必需的。在这种情况下，有没有办法让客户端验证工作

附言： 我发现，如果使用以下命令在视图中显示Address1字段，则客户端验证可以工作：

<div class="editor-field">
    @Html.Editor("Address1", Model.Address1)
    @Html.ValidationMessageFor(model => model.Address1)
</div>

@编辑器（“Address1”，Model.Address1）
@Html.ValidationMessageFor（model=>model.Address1）

Hmm，这是一个棘手的问题，因为

HtmlHelper.EditorFor

方法使用

HtmlHelper

的通用参数来确定需要哪些验证属性

---

我建议您编写自己的EditorFor扩展方法，将调用委托给非通用的HtmlHelper.Editor方法。

您是否考虑过为Person、Sender和Receiver创建自己的EditorTemplate？EditorFor和DisplayFor将查找与对象类型匹配的自定义模板

---

内部方法将查找与对象类型匹配的模板。然后，它将查找与基类匹配的模板，然后在继承链的上游。

您可以自定义来自具体类的验证程序和元数据，但解决方案有几个移动部分，包括两个自定义元数据提供程序

首先，创建一个自定义的

属性

，以修饰基类的每个属性。这对于我们的定制提供者来说是必要的，以指示何时需要进一步的分析。这是属性：

[AttributeUsage(AttributeTargets.All, Inherited = true, AllowMultiple = true)]
public class BaseTypeAttribute : Attribute { }

接下来，创建一个自定义的

modelmataprovider

继承自

dataannotationsmodelmataprovider

：

public class MyModelMetadataProvider : DataAnnotationsModelMetadataProvider
{
    protected override ModelMetadata CreateMetadata(
        IEnumerable<Attribute> attributes,
        Type containerType,
        Func<object> modelAccessor,
        Type modelType,
        string propertyName)
    {
        var attribute = attributes.FirstOrDefault(a => a.GetType().Equals(typeof(BaseTypeAttribute))) as BaseTypeAttribute;
        if (attribute != null && modelAccessor != null)
        {
            var target = modelAccessor.Target;
            var containerField = target.GetType().GetField("container");
            if (containerField == null)
            {
                var vdi = target.GetType().GetField("vdi").GetValue(target) as ViewDataInfo;
                var concreteType = vdi.Container.GetType();
                return base.CreateMetadata(attributes, concreteType, modelAccessor, modelType, propertyName);
            }
            else
            {
                var container = containerField.GetValue(target);
                var concreteType = container.GetType();
                var propertyField = target.GetType().GetField("property");
                if (propertyField == null)
                {
                    concreteType = base.GetMetadataForProperties(container, containerType)
                        .FirstOrDefault(p => p.PropertyName == "ConcreteType").Model as System.Type;
                    if (concreteType != null)
                        return base.GetMetadataForProperties(container, concreteType)
                            .FirstOrDefault(pr => pr.PropertyName == propertyName);
                }
                return base.CreateMetadata(attributes, concreteType, modelAccessor, modelType, propertyName);
            }
        }
        return base.CreateMetadata(attributes, containerType, modelAccessor, modelType, propertyName);
    }
}

public class MyModelMetadataValidatorProvider : DataAnnotationsModelValidatorProvider
{
    protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable<Attribute> attributes)
    {
        List<ModelValidator> vals = base.GetValidators(metadata, context, attributes).ToList();

        var baseTypeAttribute = attributes.FirstOrDefault(a => a.GetType().Equals(typeof(BaseTypeAttribute))) 
            as BaseTypeAttribute;

        if (baseTypeAttribute != null)
        {
            // get our parent model
            var parentMetaData = ModelMetadataProviders.Current.GetMetadataForProperties(context.Controller.ViewData.Model,
                metadata.ContainerType);

            // get the concrete type
            var concreteType = parentMetaData.FirstOrDefault(p => p.PropertyName == "ConcreteType").Model;
            if (concreteType != null)
            {
                var concreteMetadata = ModelMetadataProviders.Current.GetMetadataForProperties(context.Controller.ViewData.Model,
                    Type.GetType(concreteType.ToString()));

                var concretePropertyMetadata = concreteMetadata.FirstOrDefault(p => p.PropertyName == metadata.PropertyName);

                vals = base.GetValidators(concretePropertyMetadata, context, attributes).ToList();
            }
        }
        return vals.AsEnumerable();
    }
}

然后，在Global.asax.cs中的

应用程序\u Start

中注册两个自定义提供程序：

ModelValidatorProviders.Providers.Clear();
ModelValidatorProviders.Providers.Add(new MvcApplication8.Controllers.MyModelMetadataValidatorProvider());
ModelMetadataProviders.Current = new MvcApplication8.Controllers.MyModelMetadataProvider();

现在，按如下方式更改您的模型：

public class Person
{
    public Type ConcreteType { get; set; }

    [Required]
    [Display(Name = "Full name")]
    [BaseType]
    public string FullName { get; set; }

    [Display(Name = "Address Line 1")]
    [BaseType]
    public virtual string Address1 { get; set; }
}

public class Sender : Person
{
    public Sender()
    {
        this.ConcreteType = typeof(Sender);
    }

    [Required]
    [Display(Name = "Address Line One")]
    public override string Address1 { get; set; }
}

public class Receiver : Person
{
}

请注意，基类有一个新属性，

ConcreteType

。这将用于指示哪个继承类实例化了这个基类。每当继承类具有重写基类中元数据的元数据时，继承类的构造函数应设置基类ConcreteType属性

现在，即使视图使用基类，特定于任何具体继承类的属性也将显示在视图中，并将影响模型的验证

---

此外，您应该能够将视图转换为Person类型的模板，并将该模板用于使用基类或从基类继承的任何实例。

发件人是Person，但Person不是发件人，您的视图是强类型的Person，因此，它永远不会检测到与发件人有关的任何内容。实际上，如果您将其添加到视图中：Model.GetType（）.ToString（），您将看到显示以下内容：QuickTest.Models.sender，这意味着在呈现视图时该类型是已知的。但是，EditorFor（）会将其视为您强键入的类型，是的，我做了，但在我的例子中，发送者和接收者之间的差异并不显著，所以我不认为仅仅为了更改其顶部的@model指令而两次使用相同的视图是有意义的。var propertyField=target.GetType（）.GetField（“property”）；这一行的作用是什么？target.GetType（）.GetField（“vdi”）的作用是什么