如何使用不同的名称绑定视图模型属性

实际上,有一种方法可以做到这一点.

在ASP.NET中绑定的元数据TypeDescriptor,而不是通过直接反射.为了更加珍贵,AssociatedMetadataTypeTypeDescriptionProvider使用,反过来,TypeDescriptor.GetProvider我们只使用我们的模型类型作为参数调用:

public AssociatedMetadataTypeTypeDescriptionProvider(Type type)
  : base(TypeDescriptor.GetProvider(type))
{
}

所以,我们需要的是TypeDescriptionProvider为我们的模型设置我们的自定义.

让我们实现我们的自定义提供程序.首先,让我们定义自定义属性名称的属性:

[AttributeUsage(AttributeTargets.Property)]
public class CustomBindingNameAttribute : Attribute
{
    public CustomBindingNameAttribute(string propertyName)
    {
        this.PropertyName = propertyName;
    }

    public string PropertyName { get; private set; }
}

如果您已具有所需名称的属性,则可以重复使用它.上面定义的属性只是一个例子.我更喜欢使用,JsonPropertyAttribute因为在大多数情况下我使用json和Newtonsoft的库并且只想定义一次自定义名称.

下一步是定义自定义类型描述符.我们不会实现整个类型描述符逻辑并使用默认实现.仅覆盖属性访问:

public class MyTypeDescription : CustomTypeDescriptor
{
    public MyTypeDescription(ICustomTypeDescriptor parent)
        : base(parent)
    {
    }

    public override PropertyDescriptorCollection GetProperties()
    {
        return Wrap(base.GetProperties());
    }

    public override PropertyDescriptorCollection GetProperties(Attribute[] attributes)
    {
        return Wrap(base.GetProperties(attributes));
    }

    private static PropertyDescriptorCollection Wrap(PropertyDescriptorCollection src)
    {
        var wrapped = src.Cast<PropertyDescriptor>()
                         .Select(pd => (PropertyDescriptor)new MyPropertyDescriptor(pd))
                         .ToArray();

        return new PropertyDescriptorCollection(wrapped);
    }
}

还需要实现自定义属性描述符.同样,除属性名称之外的所有内容都将由默认描述符处理.注意,NameHashCode由于某种原因是一个单独的属性.随着名称的改变,所以它的哈希码也需要改变:

public class MyPropertyDescriptor : PropertyDescriptor
{
    private readonly PropertyDescriptor _descr;
    private readonly string _name;

    public MyPropertyDescriptor(PropertyDescriptor descr)
        : base(descr)
    {
        this._descr = descr;

        var customBindingName = this._descr.Attributes[typeof(CustomBindingNameAttribute)] as CustomBindingNameAttribute;
        this._name = customBindingName != null ? customBindingName.PropertyName : this._descr.Name;
    }

    public override string Name
    {
        get { return this._name; }
    }

    protected override int NameHashCode
    {
        get { return this.Name.GetHashCode(); }
    }

    public override bool CanResetValue(object component)
    {
        return this._descr.CanResetValue(component);
    }

    public override object GetValue(object component)
    {
        return this._descr.GetValue(component);
    }

    public override void ResetValue(object component)
    {
        this._descr.ResetValue(component);
    }

    public override void SetValue(object component, object value)
    {
        this._descr.SetValue(component, value);
    }

    public override bool ShouldSerializeValue(object component)
    {
        return this._descr.ShouldSerializeValue(component);
    }

    public override Type ComponentType
    {
        get { return this._descr.ComponentType; }
    }

    public override bool IsReadOnly
    {
        get { return this._descr.IsReadOnly; }
    }

    public override Type PropertyType
    {
        get { return this._descr.PropertyType; }
    }
}

最后,我们需要我们的自定义TypeDescriptionProvider和方法将其绑定到我们的模型类型.默认情况下,TypeDescriptionProviderAttribute旨在执行该绑定.但在这种情况下,我们无法获得我们想要在内部使用的默认提供程序.在大多数情况下,默认提供商将是ReflectTypeDescriptionProvider.但这并不能保证,并且由于它的保护级别,这个提供商是无法访问的 - 它是internal.但我们仍然希望回退到默认提供商.

TypeDescriptor还允许通过AddProvider方法为我们的类型显式添加提供程序.这就是我们将要使用的.但首先,让我们定义我们的自定义提供者本身:

public class MyTypeDescriptionProvider : TypeDescriptionProvider
{
    private readonly TypeDescriptionProvider _defaultProvider;

    public MyTypeDescriptionProvider(TypeDescriptionProvider defaultProvider)
    {
        this._defaultProvider = defaultProvider;
    }

    public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
    {
        return new MyTypeDescription(this._defaultProvider.GetTypeDescriptor(objectType, instance));
    }
}

最后一步是将我们的提供程序绑定到我们的模型类型.我们可以以任何我们想要的方式实现它.例如,让我们定义一些简单的类,例如:

public static class TypeDescriptorsConfig
{
    public static void InitializeCustomTypeDescriptorProvider()
    {
        // Assume, this code and all models are in one assembly
        var types = Assembly.GetExecutingAssembly().GetTypes()
                            .Where(t => t.GetProperties().Any(p => p.IsDefined(typeof(CustomBindingNameAttribute))));

        foreach (var type in types)
        {
            var defaultProvider = TypeDescriptor.GetProvider(type);
            TypeDescriptor.AddProvider(new MyTypeDescriptionProvider(defaultProvider), type);
        }
    }
}

并通过Web激活调用该代码:

[assembly: PreApplicationStartMethod(typeof(TypeDescriptorsConfig), "InitializeCustomTypeDescriptorProvider")]

或者只是在Application_Start方法中调用它:

public class MvcApplication : HttpApplication
{
    protected void Application_Start()
    {
        TypeDescriptorsConfig.InitializeCustomTypeDescriptorProvider();

        // rest of init code ...
    }
}

但这不是故事的结局.:(

考虑以下模型:

public class TestModel
{
    [CustomBindingName("actual_name")]
    [DisplayName("Yay!")]
    public string TestProperty { get; set; }
}

如果我们尝试写.cshtml视图如下:

@model Some.Namespace.TestModel
@Html.DisplayNameFor(x => x.TestProperty) @* fail *@

我们会得到ArgumentException:

System.Web.Mvc.dll中出现"System.ArgumentException"类型的异常,但未在用户代码中处理

其他信息:找不到属性Some.Namespace.TestModel.TestProperty.

因为所有帮助者很快或后来都会调用ModelMetadata.FromLambdaExpression方法.这个方法接受我们提供的表达式(x => x.TestProperty)并直接从成员信息中获取成员名称,并且不知道我们的任何属性,元数据(谁在乎,呵呵？):

internal static ModelMetadata FromLambdaExpression<TParameter, TValue>(/* ... */)
{
    // ...

        case ExpressionType.MemberAccess:
            MemberExpression memberExpression = (MemberExpression) expression.Body;
            propertyName = memberExpression.Member is PropertyInfo ? memberExpression.Member.Name : (string) null;
            //                                  I want to cry here - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    // ...
}

对于x => x.TestProperty(这里x是TestModel)这个方法将返回TestProperty,而不是actual_name,但模型元数据包含actual_name属性,没有TestProperty.这就是the property could not be found抛出错误的原因.

这是设计失败.

尽管如此不便,但有几种解决方法,例如:

最简单的方法是通过他们重新定义的名称访问我们的成员:

@model Some.Namespace.TestModel
@Html.DisplayName("actual_name") @* this will render "Yay!" *@

这个不好.根本没有intellisense,因为我们的模型更改,我们将没有任何编译错误.任何改变都可以打破,没有简单的方法来检测它.

另一种方法有点复杂 - 我们可以创建自己的助手版本,并禁止任何人调用默认助手或 ModelMetadata.FromLambdaExpression具有重命名属性的模型类.

最后,首选两者的组合:编写自己的模拟以获取具有重定义支持的属性名称,然后将其传递给默认帮助程序.像这样的东西:

@model Some.Namespace.TestModel
@Html.DisplayName(Html.For(x => x.TestProperty)) 

编译时和智能感知支持,无需花费大量时间来完成整套帮助.利润!

此外,上面描述的所有内容都像模型绑定的魅力.在模型绑定过程中,默认绑定器也使用收集的元数据TypeDescriptor.

但我想绑定json数据是最好的用例.您知道,许多Web软件和标准都使用lowercase_separated_by_underscores命名约定.不幸的是,这不是C#的通常惯例.拥有以不同惯例命名的成员的课程看起来很丑陋,最终可能会遇到麻烦.特别是当你有工具每次抱怨命名违规时.

ASP.NET MVC默认模型绑定器不会像调用newtonsoft JsonConverter.DeserializeObject方法时那样将json绑定到模型.相反,json解析为字典.例如:

{
    complex: {
        text: "blabla",
        value: 12.34
    },
    num: 1
}

将被翻译成以下字典:

{ "complex.text", "blabla" }
{ "complex.value", "12.34" }
{ "num", "1" }