asp.net核心web 2中的抽象类模型绑定

Question

我一直试图找出如何使用自定义模型绑定到.net Core2WebAPI，但一直未能使它发挥作用。

我读过一些文章，如下所示：http://www.palmmedia.de/Blog/2018/5/13/aspnet-core-model-binding-of-abstract-classes Asp net core rc2. Abstract class model binding

在我的例子中，bindingContext.ModelName总是空的。有人能解释为什么会这样吗？

下面的示例实现

控制器

        public IActionResult SomeAction([ModelBinder(BinderType = typeof(BlahTypeModelBinder))][FromBody]TheBaseClass theBase)
    {
        return Ok();
    }

模型

public abstract class TheBaseClass
{
    public abstract int WhatType { get; }
}

public class A : TheBaseClass
{
    public override int WhatType { get { return 1; }  }
}

public class B : TheBaseClass
{
    public override int WhatType { get { return 2; } }
}

提供程序

public class BhalTypeBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context == null)
            throw new ArgumentNullException(nameof(context));

        if (context.Metadata.ModelType == typeof(TheBaseClass))
        {
            var assembly = typeof(TheBaseClass).Assembly;
            var abstractSearchClasses = assembly.GetExportedTypes()
                .Where(t => t.BaseType.Equals(typeof(TheBaseClass)))
                .Where(t => !t.IsAbstract)
                .ToList();

            var modelBuilderByType = new Dictionary<Type, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.ComplexTypeModelBinder>();

            foreach (var type in abstractSearchClasses)
            {
                var propertyBinders = new Dictionary<ModelMetadata, IModelBinder>();
                var metadata = context.MetadataProvider.GetMetadataForType(type);

                foreach (var property in metadata.Properties)
                {
                    propertyBinders.Add(property, context.CreateBinder(property));
                }

                modelBuilderByType.Add(type, new Microsoft.AspNetCore.Mvc.ModelBinding.Binders.ComplexTypeModelBinder(propertyBinders));
            }

            return new BlahTypeModelBinder(modelBuilderByType, context.MetadataProvider);
        }

        return null;
    }
}

粘结剂

public class BlahTypeModelBinder : IModelBinder
{
    private readonly IModelMetadataProvider _metadataProvider;
    private readonly IDictionary<Type, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.ComplexTypeModelBinder> _binders;

    public BlahTypeModelBinder(IDictionary<Type, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.ComplexTypeModelBinder> binders, IModelMetadataProvider metadataProvider)
    {
        _metadataProvider = metadataProvider;
        _binders = binders;
    }

    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        if (bindingContext == null)
            throw new ArgumentNullException(nameof(bindingContext));

        var modelTypeValue = bindingContext.ValueProvider.GetValue(ModelNames.CreatePropertyModelName(bindingContext.ModelName, "WhatType"));
        if (modelTypeValue != null && modelTypeValue.FirstValue != null)
        {
            Type modelType = Type.GetType(modelTypeValue.FirstValue);
            if (this._binders.TryGetValue(modelType, out var modelBinder))
            {
                ModelBindingContext innerModelBindingContext = DefaultModelBindingContext.CreateBindingContext(
                    bindingContext.ActionContext,
                    bindingContext.ValueProvider,
                    this._metadataProvider.GetMetadataForType(modelType),
                    null,
                    bindingContext.ModelName);

                /*modelBinder*/
                this._binders.First().Value.BindModelAsync(innerModelBindingContext);

                bindingContext.Result = innerModelBindingContext.Result;
                return Task.CompletedTask;
            }
        }

       //More code
    }
}

Answer 1

我终于设法解决了这个问题。你不需要提供者。只是下面的活页夹起作用

public class BlahTypeModelBinder : IModelBinder
{
    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        if (bindingContext == null)
            throw new ArgumentNullException(nameof(bindingContext));

        var json = ExtractRequestJson(bindingContext.ActionContext);
        var jObject = Newtonsoft.Json.Linq.JObject.Parse(json);
        var whatTypeInt = (int)jObject.SelectToken("WhatType");

        if (whatTypeInt == 1)
        {
            var obj = DeserializeObject<A>(json);
            bindingContext.Result = ModelBindingResult.Success(obj);
        }
        else if (whatTypeInt == 2)
        {
            var obj = DeserializeObject<B>(json);
            bindingContext.Result = ModelBindingResult.Success(obj);
        }
        else
        {
            bindingContext.Result = ModelBindingResult.Failed();
            return Task.CompletedTask;
        }

        return Task.CompletedTask;
    }

    private static string ExtractRequestJson(ActionContext actionContext)
    {
        var content = actionContext.HttpContext.Request.Body;
        return new StreamReader(content).ReadToEnd();
    }

    private static T DeserializeObject<T>(string json)
    {
        return Newtonsoft.Json.JsonConvert.DeserializeObject<T>(json, new Newtonsoft.Json.JsonSerializerSettings
        {
            TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Auto
        });
    }
}

Answer 2

链接以使用外部查询字符串参数确定类型的示例。

如果您的调用您的操作，如：SomeAction?WhatType=YourNamespaceName.A，则绑定将按预期的方式工作。

bindingContext.ModelName是空的很好，它将在模型绑定之后设置。如果需要，可以在设置bindingContext.Result之后设置它。参数WhatType来自于QueryStringValueProvider，所以没有前缀是可以的。

如何单独完成基于JSON的抽象模型绑定

为此，我们需要：

1. 一个值提供程序来读取JSON并为我们提供一些"WhatType“值，以代替QueryStringValueProvider。
2. 将提取的数字映射到Type-s的一些反射。

1. ValueProvider

这里有一篇关于创建ValueProviders的详细文章：

作为起点，这里有一些代码成功地从正文json中提取WhatType整数：

    public class BlahValueProvider : IValueProvider
{
    private readonly string _requestBody;

    public BlahValueProvider(string requestBody)
    {
        _requestBody = requestBody;
    }

    private const string PROPERTY_NAME = "WhatType";

    public bool ContainsPrefix(string prefix)
    {
        return prefix == PROPERTY_NAME;
    }

    public ValueProviderResult GetValue(string key)
    {
        if (key != PROPERTY_NAME)
            return ValueProviderResult.None;

        // parse json

        try
        {
            var json = JObject.Parse(_requestBody);
            return new ValueProviderResult(json.Value<int>("WhatType").ToString());
        }
        catch (Exception e)
        {
            // TODO: error handling
            throw;
        }
    }
}

public class BlahValueProviderFactory : IValueProviderFactory
{
    public Task CreateValueProviderAsync(ValueProviderFactoryContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }

        var request = context.ActionContext.HttpContext.Request;
        if (request.ContentType == "application/json")
        {
            return AddValueProviderAsync(context);
        }

        return Task.CompletedTask;
    }

    private Task AddValueProviderAsync(ValueProviderFactoryContext context)
    {
        using (StreamReader sr = new StreamReader(context.ActionContext.HttpContext.Request.Body))
        {
            string bodyString = sr.ReadToEnd();
            context.ValueProviders.Add(new BlahValueProvider(bodyString));
        }

        return Task.CompletedTask;
    }
}

当然，，您必须在Startup.cs中注册这个工厂，就像您注册模型活页夹一样。这绝对没有将提取的数字转换为实际的类型(关于这个问题，请参见下面的第2点)，但是如果在您的行上放置一个断点与if (modelTypeValue != null一起看，您可以看到，即使没有单独的GET参数，modelTypeValue也在您的身边。

2.反思

请注意，您正在尝试根据一个在现有实例上动态计算的属性(它们不是静态的)来确定类型。虽然通过了解当前的实现，我知道这是可能的(创建模型的空实例，检查WhatType属性，丢弃实例)，但这是非常糟糕的做法，因为没有什么可以保证实例属性是静态不变的。

这个干净的解决方案将是一个属性，它包含该类的WhatType编号。然后我们可以考虑这个属性并构建一个映射，将ints映射到Types，如果这个问题超出了范围，但是如果您不熟悉的话，可以查找任何自定义属性教程，并且您将能够非常快地将它组合在一起。