Ignore XML namespace when modelbinding in asp net core web api

You can use custom InputFormatter,here is a demo:

XmlSerializerInputFormatterNamespace:

public class XmlSerializerInputFormatterNamespace : InputFormatter, IInputFormatter, IApiRequestFormatMetadataProvider

    {
        public XmlSerializerInputFormatterNamespace()
        {
            SupportedMediaTypes.Add("application/xml");
        }
        public override async Task<InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
        {
            var xmlDoc = await XDocument.LoadAsync(context.HttpContext.Request.Body, LoadOptions.None, CancellationToken.None);
            Dictionary<string, string> d = new Dictionary<string, string>();
            foreach (var elem in xmlDoc.Descendants())
            {
                d[elem.Name.LocalName] = elem.Value;
            }
            return InputFormatterResult.Success(new Person { Id = Int32.Parse(d["Id"]), Name = d["Name"] }); 
        }
       

    }

Person：

public class Person
{
    public string Name { get; set; }

    public int Id { get; set; }
}

startup:

services.AddMvc(options =>
            {
                options.RespectBrowserAcceptHeader = true; // false by default
                options.InputFormatters.Insert(0, new XmlSerializerInputFormatterNamespace());
            }).SetCompatibilityVersion(CompatibilityVersion.Version_2_2)
           .AddXmlSerializerFormatters()
          .AddXmlDataContractSerializerFormatters();

result:

So, in order to be able to modelbind XML to a class without taking namespaces into consideration I created new InputFormatter. And I use XmlTextReader in order to ignore namespaces. Microsoft recommends to use XmlReader rather than XmlTextReader. But since XmlTextReader is there still (in .Net 6.0 Preview 3) I'll use it for now.

Simply create an inputformatter that inherits from XmlSerializerInputFormatter like so:

public class XmlNoNameSpaceInputFormatter : XmlSerializerInputFormatter
{
    private const string ContentType = "application/xml";
    public XmlNoNameSpaceInputFormatter(MvcOptions options) : base(options)
    {
        SupportedMediaTypes.Add(ContentType);
    }

    public override bool CanRead(InputFormatterContext context)
    {
        var contentType = context.HttpContext.Request.ContentType;
        return contentType.StartsWith(ContentType);
    }

    public override async Task<InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
    {
        var type = GetSerializableType(context.ModelType);
        var request = context.HttpContext.Request;

        using (var reader = new StreamReader(request.Body))
        {
            var content = await reader.ReadToEndAsync();
            Stream s = new MemoryStream(Encoding.UTF8.GetBytes(content));

            XmlTextReader rdr = new XmlTextReader(s);
            rdr.Namespaces = false;
            var serializer = new XmlSerializer(type);
            var result = serializer.Deserialize(rdr);
            return await InputFormatterResult.SuccessAsync(result);
        }
    }
}

Then add it to the inputformatters like so:

        services.AddControllers(o => 
        {
            o.InputFormatters.Add(new XmlNoNameSpaceInputFormatter(o));
        })
        .AddXmlSerializerFormatters();

Now we can modelbind Person or any other class no matter if there is namespaces or not in the incoming XML. Thanks to @yiyi-you

Here's an implementation that uses the built-in types as much as possible, because they have a ton of optimizations:

// inherits from the built-in implementation
internal sealed class NamespaceAgnosticXmlInputFormatter(MvcOptions options) : XmlSerializerInputFormatter(options)
{
    protected override XmlReader CreateXmlReader(Stream readStream, Encoding encoding)
        => new NamespaceAgnosticXmlReader(base.CreateXmlReader(readStream, encoding));

    // a wrapper for the built-in implementation
    private sealed class NamespaceAgnosticXmlReader(XmlReader reader) : XmlReader
    {
        private readonly XmlReader _reader = reader;

        // ignore namespace infos
        public override string NamespaceURI => string.Empty;
        public override string Prefix => string.Empty;
        public override string Name => this.LocalName;

        public override int AttributeCount => _reader.AttributeCount;
        public override string BaseURI => _reader.BaseURI;
        public override int Depth => _reader.Depth;
        public override bool EOF => _reader.EOF;
        public override bool IsEmptyElement => _reader.IsEmptyElement;
        public override string LocalName => _reader.LocalName;
        public override XmlNameTable NameTable => _reader.NameTable;
        public override XmlNodeType NodeType => _reader.NodeType;
        public override ReadState ReadState => _reader.ReadState;
        public override string Value => _reader.Value;

        public override string GetAttribute(int i) => _reader.GetAttribute(i);
        public override string? GetAttribute(string name) => _reader.GetAttribute(name);
        public override string? GetAttribute(string name, string? namespaceURI) => _reader.GetAttribute(name, namespaceURI);
        public override string? LookupNamespace(string prefix) => _reader.LookupNamespace(prefix);
        public override bool MoveToAttribute(string name) => _reader.MoveToAttribute(name);
        public override bool MoveToAttribute(string name, string? ns) => _reader.MoveToAttribute(name, ns);
        public override bool MoveToElement() => _reader.MoveToElement();
        public override bool MoveToFirstAttribute() => _reader.MoveToFirstAttribute();
        public override bool MoveToNextAttribute() => _reader.MoveToNextAttribute();
        public override bool Read() => _reader.Read();
        public override bool ReadAttributeValue() => _reader.ReadAttributeValue();
        public override void ResolveEntity() => _reader.ResolveEntity();
    }
}