如何从继承的 FromBody 模型中获得正确的类型？

Question

body 的帖子有几种不同的 XML 传入。所有的 XMLS 几乎都是一样的，所以我先添加一个基类，其他 XMLS 继承自基类。

这是模型：

[XmlInclude(typeof(TextMsg))]
[XmlRoot("xml")]        
public class BaseClass
{
    public string ToUserName { get; set; }
    public string FromUserName { get; set; }
    public string CreateTime { get; set; }
    public string MsgType { get; set; }            
}        
[XmlRoot("xml")]        
public class TextMsg : BaseClass
{
    public TextMsg()
    {
        MsgType = "text";
    }
    public string Content { get; set; }
    public string MsgId { get; set; }
}

还有几个类也继承自基类模型，现在我在这里只展示一个。

方法如下：

[HttpPost]
[Produces("application/xml")]
public async Task<IActionResult> mp([FromBody]BaseClass XmlData)
{
    BaseClass ReturnXmlData = null;
    var a = XmlData.GetType();            
    return Ok(ReturnXmlData);
}  

远程服务器将向我的服务器发布一个包含 XML 的请求。现在传入变量XmlData 只获取基类的值和类型。

我需要得到真正的值和类型，然后通过传入的类型和值返回不同的XML。

我该如何解决这个问题？谢谢。

---

这是传入的 XML 之一，匹配上面的 TextMsg 模型：

<xml> 
<ToUserName>123</ToUserName>
<FromUserName>456</FromUserName>
<CreateTime>1348831860</CreateTime>
<MsgType>text</MsgType>
<Content>this is a test</Content>
<MsgId>1234567890123456</MsgId>
</xml>

Answer 1

您可以为此创建自定义模型绑定器

public class XmlBinder : IModelBinder
{
    public async Task BindModelAsync(ModelBindingContext bindingContext)
    {
        try
        {
            var memoryStream = new MemoryStream();
            await bindingContext.HttpContext.Request.Body.CopyToAsync(memoryStream);
            memoryStream.Seek(0, SeekOrigin.Begin);
            XElement root = XElement.Load(memoryStream);
            memoryStream.Seek(0, SeekOrigin.Begin);

            string messageType = root.Element("MsgType").Value;
            Type xmlType = GetTypeFromMessage(messageType);
            var serializer = new XmlSerializer(xmlType);
            var model = serializer.Deserialize(memoryStream);

            bindingContext.Result = ModelBindingResult.Success(model);
        }
        catch
        {
            bindingContext.Result = ModelBindingResult.Failed();
        }
    }

    private Type GetTypeFromMessage(string msgType)
    {
        switch (msgType)
        {
            case "text":
                return typeof(TextMsg);
            case "image":
                return typeof(ImageMsg);
            //... other cases
            default:
                return typeof(BaseClass);
        }
    }
}

将此模型绑定器应用于BaseClass

[ModelBinder(typeof(XmlBinder))]
public class BaseXml

Answer 2

你可以根据source code写出你自己的XmlSerializerInputFormatter，例如：

[Obsolete]
public class XmlCreationConverter: XmlSerializerInputFormatter
{    
    public override async Task<InputFormatterResult> ReadRequestBodyAsync(
       InputFormatterContext context,
       Encoding encoding)
    {
        XElement xml = null;
        Type type = typeof(BaseClass);
        var request = context.HttpContext.Request;

        context.HttpContext.Request.EnableRewind();
        using (StreamReader reader = new StreamReader(request.Body))
        {
            reader.BaseStream.Seek(0, SeekOrigin.Begin);
            string text = reader.ReadToEnd();
            request.Body.Position = 0; // rewind
            xml = XElement.Parse(text);

            //your logic to return the right type
            if (xml.Element("MsgType").Value == "text")
            {
                type = typeof(TextMsg);
            }
            else if(...)
            {
                type = ...
            }
            else
            {
            }

            using (XmlReader xmlReader = CreateXmlReader(request.Body, encoding))
            {
                var serializer = GetCachedSerializer(type);
                var deserializedObject = serializer.Deserialize(xmlReader);
                return InputFormatterResult.Success(deserializedObject);
            }
        }
    }

}

Startup.cs：

services.AddMvc(options=> options.InputFormatters.Add(new XmlCreationConverter()))
                .AddXmlSerializerFormatters()
                .SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

行动：

[HttpPost]
[Produces("application/xml")]
public async Task<IActionResult> mp([FromBody]BaseClass XmlData)

更新： 对于 asp.net core 3.0，将代码更改为以下：

public class XmlCreationConverter : XmlSerializerInputFormatter
{
    private readonly MvcOptions _options;
    public XmlCreationConverter(MvcOptions options) : base(options)

    {
        _options = options;
    }
    public override async Task<InputFormatterResult> ReadRequestBodyAsync(
       InputFormatterContext context,
       Encoding encoding)
    {
        XElement xml = null;
        Type type = typeof(BaseClass);
        var request = context.HttpContext.Request;

        context.HttpContext.Request.EnableBuffering();

       //for model type is Baseclass
       if (context.ModelType == typeof(BaseClass))
        {
            using (StreamReader reader = new StreamReader(request.Body))
            {
                var text = await reader.ReadToEndAsync();
                request.Body.Position = 0;
                xml = XElement.Parse(text);
                if (xml.Element("MsgType").Value == "text")
                {
                    type = typeof(TextMsg);
                }

                using (XmlReader xmlReader = CreateXmlReader(request.Body, encoding))
                {
                    var serializer = GetCachedSerializer(type);
                    var deserializedObject = serializer.Deserialize(xmlReader);
                    return InputFormatterResult.Success(deserializedObject);
                }
            }
        }
        else if(context.ModelType == ...)
        else
        {
            using (StreamReader reader = new StreamReader(request.Body))
            {
                var text = await reader.ReadToEndAsync();
                request.Body.Position = 0;
                using (var xmlReader = CreateXmlReader(request.Body, encoding))
                {
                    var modelType = GetSerializableType(context.ModelType);

                    var serializer = GetCachedSerializer(modelType);

                    var deserializedObject = serializer.Deserialize(xmlReader);

                    // Unwrap only if the original type was wrapped.
                    if (type != context.ModelType)
                    {
                        if (deserializedObject is IUnwrappable unwrappable)
                        {
                            deserializedObject = unwrappable.Unwrap(declaredType: context.ModelType);
                        }
                    }

                    return InputFormatterResult.Success(deserializedObject);
                }
            }
        }

    }
}

Startup.cs

services.AddMvc(options => options.InputFormatters.Add(new XmlCreationConverter(options)))
                .AddXmlSerializerFormatters();

Answer 3

您必须创建一个自定义模型绑定器，这超出了 Stack Overflow 的范围。使用默认的模型绑定器，参数的类型将被实例化，并且正文中不适合该类型的任何内容都将被丢弃。因此，您最终会得到一个 BaseClass 的实例，无法将其转换为任何更具体的派生类型。

唯一的开箱即用选项是逐字绑定到您想要的类类型（即派生类型，而不是基类型），并为每个派生类型提供备用端点。或者，您可以创建一个包含所有各种派生类型的所有属性以便绑定的超类，然后根据填充的属性，您可以手动映射到适当的派生类。