使用Web API默认模型绑定器自定义属性名称？

Question

我有一个请求模型类，我正在尝试使用默认的Web API 2模型绑定（.NET 4.6.1）。一些查询字符串参数与模型属性匹配，但有些参数不匹配。

public async Task<IHttpActionResult> Get([FromUri]MyRequest request) {...}

示例查询字符串：

/api/endpoint?country=GB

样本模型属性：

public class MyRequest
{
    [JsonProperty("country")] // Did not work
    [DataMember(Name = "country")] // Also did not work
    public string CountryCode { get; set; }
    // ... other properties
}

有没有办法在我的模型上使用属性（就像你可能使用[JsonProperty("country")]）来避免实现自定义模型绑定？或者最好的方法是使用创建特定模型来QueryString绑定，然后使用AutoMapper来自定义差异？

Answer 1

迟到的答案，但我最近也碰到了这个问题。你可以简单地使用BindProperty属性：

public class MyRequest
{
    [BindProperty(Name = "country")]
    public string CountryCode { get; set; }
}

在.NET Core 2.1和2.2上测试过

Answer 2

基于进一步的研究，Web API中的默认模型绑定行为不支持JsonProperty或DataMember属性，并且大多数可能的解决方案似乎是（1）自定义模型绑定器或（2）维护2组模型以及它们之间的映射。

• JSON to Model property binding using JsonProperty
• Changing the parameter name Web Api model binding

我选择了自定义模型绑定器（下面的实现），所以我可以重复使用它，而不必复制我的所有模型（并维护每个模型之间的映射）。

用法

下面的实现允许我让任何模型可选地使用JsonProperty进行模型绑定，但如果没有提供，则默认只使用属性名称。它支持标准.NET类型（字符串，int，double等）的映射。还没有准备好生产，但到目前为止它符合我的用例。

[ModelBinder(typeof(AttributeModelBinder))]
public class PersonModel
{
    [JsonProperty("pid")]
    public int PersonId { get; set; }

    public string Name { get; set; }
}

这允许在请求中映射以下查询字符串：

/api/endpoint?pid=1&name=test

履行

首先，该解决方案定义了一个映射属性，用于跟踪模型的源属性以及从值提供程序设置值时要使用的目标名称。

public class MappedProperty
{
    public MappedProperty(PropertyInfo source)
    {
        this.Info = source;
        this.Source = source.Name;
        this.Target = source.GetCustomAttribute<JsonPropertyAttribute>()?.PropertyName ?? source.Name;
    }
    public PropertyInfo Info { get; }
    public string Source { get; }
    public string Target { get; }
}

然后，定义自定义模型绑定器以处理映射。它缓存反射的模型属性，以避免在后续调用中重复反射。它可能还没有完全准备就绪，但最初的测试一直很有希望。

public class AttributeModelBinder : IModelBinder
{
    public static object _lock = new object();
    private static Dictionary<Type, IEnumerable<MappedProperty>> _mappings = new Dictionary<Type, IEnumerable<MappedProperty>>();


    public IEnumerable<MappedProperty> GetMapping(Type type)
    {
        if (_mappings.TryGetValue(type, out var result)) return result; // Found
        lock (_lock)
        {
            if (_mappings.TryGetValue(type, out result)) return result; // Check again after lock
            return (_mappings[type] = type.GetProperties().Select(p => new MappedProperty(p)));
        }
    }

    public object Convert(Type target, string value)
    {
        try
        {
            var converter = TypeDescriptor.GetConverter(target);
            if (converter != null)
                return converter.ConvertFromString(value);
            else
                return target.IsValueType ? Activator.CreateInstance(target) : null;
        }
        catch (NotSupportedException)
        {
            return target.IsValueType ? Activator.CreateInstance(target) : null;
        }
    }

    public void SetValue(object model, MappedProperty p, IValueProvider valueProvider)
    {
        var value = valueProvider.GetValue(p.Target)?.AttemptedValue;
        if (value == null) return;
        p.Info.SetValue(model, this.Convert(p.Info.PropertyType, value));
    }

    public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
    {
        try
        {
            var model = Activator.CreateInstance(bindingContext.ModelType);
            var mappings = this.GetMapping(bindingContext.ModelType);
            foreach (var p in mappings)
                this.SetValue(model, p, bindingContext.ValueProvider);
            bindingContext.Model = model;
            return true;
        }
        catch (Exception ex)
        {
            return false;
        }
    }
}