使用XMLSerializer的deperialization空XML属性值

Question

我从第三方获得XML，需要将其列为C＃对象。此XML可能包含具有整数类型或空值的值的属性：attr =“ 11”或attr =“”。我想通过可随机整数的类型将此属性值列为属性。但是XMLSerializer不支持避难所化为无效类型。以下测试代码在使用InvalidOperationException创建XMLSerializer期间失败{“存在反映类型'testConsoLeApplication.serializeme'的错误。”}。

[XmlRoot("root")]
public class SerializeMe
{
    [XmlElement("element")]
    public Element Element { get; set; }
}

public class Element
{
    [XmlAttribute("attr")]
    public int? Value { get; set; }
}

class Program {
    static void Main(string[] args) {
        string xml = "<root><element attr=''>valE</element></root>";
        var deserializer = new XmlSerializer(typeof(SerializeMe));
        Stream xmlStream = new MemoryStream(Encoding.ASCII.GetBytes(xml));
        var result = (SerializeMe)deserializer.Deserialize(xmlStream);
    }
}

当我将“值”属性的类型更改为INT时，对于InvalidOperationException而言，避难所失败：

XML文档（1，16）中存在错误。

任何人都可以建议如何将属性带入空属性类型（作为零）（作为零），同时应将非空属性值归为整数？有什么技巧，所以我不必手动对每个字段进行挑选（实际上有很多）？

在Ahsteele的评论后更新：

1. 据我所知，此属性仅适用于xmlelementAttribute-此属性指定该元素没有内容，无论是子元素还是身体文本。但是我需要找到Xmlattributeattribute的解决方案。无论如何，我无法更改XML，因为我无法控制它。

2. bool *指定的属性

   仅在属性值不空时或丢失属性时，此属性才起作用。当atter具有空值（attr =''）时，xmlSerializer构造函数失败（如预期）。

    公共类元素
   {
       [xmlattribute（“ attr”）]
       public int value {get;放; }
   
       [xmlignore]
       公共布尔值规定；
   }
    

3. 我试图通过此博客文章将课程采用到我的问题：

     [xmlattribute（“ attr”）]
   公共nullableInt值{get;放; } 
    

   但是xmlSerializer构造函数失败了InvalidOperationException：

   不能序列化testConsoLeApplication.nullableInt类型的成员“值”。

   xmlattribute/xmlText不能用于编码实现IxmlSerializable}

   的类型

4. 丑陋的替代解决方案的类型（对我感到羞耻，我在此处写了此代码:)）：

    公共类元素
   {
       [xmlattribute（“ attr”）]
       公共字符串setValue {get;放; }
   
       公共INT？ getValue（）
       {
           if（string.isnullorenty（setValue）|| setValue.trim（）。长度＆lt; = 0）
               返回null;
   
           int结果；
           if（int.tryparse（setValue，out结果））
               返回结果；
   
           返回null;
       }
   }
    

   ，但我不想提出这样的解决方案，因为它为消费者打破了我的班级的接口。我最好手动地实现IXMLSerializable界面。

目前，我似乎必须为整个元素类实现IXMLSerializizizizizable（这很大），而且没有简单的解决方法…

Answer 1

这应该有效：

[XmlIgnore]
public int? Age { get; set; }

[XmlElement("Age")]
public string AgeAsText
{
  get { return (Age.HasValue) ? Age.ToString() : null; } 
  set { Age = !string.IsNullOrEmpty(value) ? int.Parse(value) : default(int?); }
}

Answer 2

我通过实现IXMLSerializable接口解决了这个问题。我没有找到更轻松的方法。

这是测试代码样本：

[XmlRoot("root")]
public class DeserializeMe {
    [XmlArray("elements"), XmlArrayItem("element")]
    public List<Element> Element { get; set; }
}

public class Element : IXmlSerializable {
    public int? Value1 { get; private set; }
    public float? Value2 { get; private set; }

    public void ReadXml(XmlReader reader) {
        string attr1 = reader.GetAttribute("attr");
        string attr2 = reader.GetAttribute("attr2");
        reader.Read();

        Value1 = ConvertToNullable<int>(attr1);
        Value2 = ConvertToNullable<float>(attr2);
    }

    private static T? ConvertToNullable<T>(string inputValue) where T : struct {
        if ( string.IsNullOrEmpty(inputValue) || inputValue.Trim().Length == 0 ) {
            return null;
        }

        try {
            TypeConverter conv = TypeDescriptor.GetConverter(typeof(T));
            return (T)conv.ConvertFrom(inputValue);
        }
        catch ( NotSupportedException ) {
            // The conversion cannot be performed
            return null;
        }
    }

    public XmlSchema GetSchema() { return null; }
    public void WriteXml(XmlWriter writer) { throw new NotImplementedException(); }
}

class TestProgram {
    public static void Main(string[] args) {
        string xml = @"<root><elements><element attr='11' attr2='11.3'/><element attr='' attr2=''/></elements></root>";
        XmlSerializer deserializer = new XmlSerializer(typeof(DeserializeMe));
        Stream xmlStream = new MemoryStream(Encoding.ASCII.GetBytes(xml));
        var result = (DeserializeMe)deserializer.Deserialize(xmlStream);
    }
}

Answer 3

我最近一直在处理很多序列化，并在处理值类型的无数据数据时发现了以下文章和帖子。

如何使c＃中的xmlSerializer在c＃ - serialization 中详细介绍XMLSerialializer的漂亮技巧。具体而言，XMLSerialier寻找XXXSPEFIFIED BOOLEAN属性以确定是否应包括在内，这使您可以忽略nulls。

亚历克斯·斯科德利（Alex Scordellis）问了一个stackoverflow问题，该问题收到一个很好的答案。亚历克斯还在他的博客上做了很好的文章，他试图解决 使用XmlSerializer将其验证为无效的＆lt; int＆gt; 。

Answer 4

以为我最好把答案扔到帽子上：
通过创建实现IXMLSerializable界面的自定义类型来解决此问题：

假设您有一个带有以下节点的XML对象：

<ItemOne>10</Item2>
<ItemTwo />

表示它们的对象：

public class MyItems {
    [XmlElement("ItemOne")]
    public int ItemOne { get; set; }

    [XmlElement("ItemTwo")]
    public CustomNullable<int> ItemTwo { get; set; } // will throw exception if empty element and type is int
}

动态无效的struct，以表示任何潜在的无效条目以及转换的转换

public struct CustomNullable<T> : IXmlSerializable where T: struct {
    private T value;
    private bool hasValue;

    public bool HasValue {
        get { return hasValue; }
    }

    public T Value {
        get { return value; }
    }

    private CustomNullable(T value) {
        this.hasValue = true;
        this.value = value;
    }

    public XmlSchema GetSchema() {
        return null;
    }

    public void ReadXml(XmlReader reader) {
        string strValue = reader.ReadString();
        if (String.IsNullOrEmpty(strValue)) {
            this.hasValue = false;
        }
        else {
            T convertedValue = strValue.To<T>();
            this.value = convertedValue;
            this.hasValue = true;
        }
        reader.ReadEndElement();

    }

    public void WriteXml(XmlWriter writer) {
        throw new NotImplementedException();
    }

    public static implicit operator CustomNullable<T>(T value) {
        return new CustomNullable<T>(value);
    }

}

public static class ObjectExtensions {
    public static T To<T>(this object value) {
        Type t = typeof(T);
        // Get the type that was made nullable.
        Type valueType = Nullable.GetUnderlyingType(typeof(T));
        if (valueType != null) {
            // Nullable type.
            if (value == null) {
                // you may want to do something different here.
                return default(T);
            }
            else {
                // Convert to the value type.
                object result = Convert.ChangeType(value, valueType);
                // Cast the value type to the nullable type.
                return (T)result;
            }
        }
        else {
            // Not nullable.
            return (T)Convert.ChangeType(value, typeof(T));
        }
    }
}

Answer 5

您也可以通过将 XML 加载到 xmldocument 中，然后将其列为 JSON 以获取对象 t 您正在寻找的。

        public static T XmlToModel<T>(string xml)
        {

            XmlDocument doc = new XmlDocument();
            doc.LoadXml(xml);

            string jsonText = JsonConvert.SerializeXmlNode(doc);

            T result = JsonConvert.DeserializeObject<T>(jsonText);

            return result;
        }

Answer 6

您需要两个课。头等舱是您的挑选性课程。任何无效的属性都应是字符串。

您这样装饰它：

[XmlAttribute("my_prop_from_xml")]
public string MyPropFromXML { get; set; }

它处理您的避难所。

您的第二堂课适合您的项目/DB。
它的属性看起来像这样：

public bool? MyPropForProject { get; set; }

您使用汽车应用程序或其他策略映射：

MyPropForProject = m.MyPropFromXML.ToNullableBool();

这可以使您的逻辑限制，并且您的课程专门用于他们应该做的事情。

这是.tonullableBool（）的一个示例：

public static bool? ToNullableBool(this string str)
{
    if (bool.TryParse(str, out bool b))
    {
        return b;
    }

    if (int.TryParse(str, out int i))
    {
        if (i == 0)
        {
            return false;
        }
        else if (i == 1)
        {
            return true;
        }
    }

    return null;
}

显然，您可以忽略此建议，使用Xmlignore，一个setter和getter分配字段/属性，然后在设置为字段时将此扩展类称为...但这完全取决于您。

Answer 7

我需要进行无法修改的XML，缺少某些属性，我需要使它们无效。

很长一段时间以来，我一直在寻找一种简单而有效的解决方案，但不幸的是没有这样的解决方案。我不得不为具有无效字段的课程编写自己的IXMLSerializizizizizizizizizizizizizallizized。

#nullable enable
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Schema;
using System.Xml.Serialization;
using System.Xml.XPath;
    
public abstract class XmlNullableSerializable : IXmlSerializable
{
    private static ConcurrentDictionary<int, XmlSerializer> SerializerCache { get; } = new();

    public virtual void ReadXml(XmlReader reader)
    {
        var xmlObject = XElement.Parse(reader.ReadOuterXml());
        var props = GetType().GetProperties().Where(x => x.CanWrite);

        foreach (var prop in props)
        {
            switch (prop.PropertyType)
            {
                case { } type when IsEnumerableType(type):
                {
                    var propName = GetXmlElementName(prop);
                    var xmlProps = xmlObject.XPathSelectElements(propName).ToList();

                    var value = GetValueFromEnumerableType(xmlProps, prop);
                    prop.SetValue(this, value ?? prop.GetValue(this), null);

                    break;
                }
                case { IsClass: true }:
                {
                    var propName = GetXmlElementName(prop);
                    var xmlProp = xmlObject.XPathSelectElement(propName);

                    var value = GetValueFromRefType(xmlProp, prop);
                    prop.SetValue(this, value ?? prop.GetValue(this), null);

                    break;
                }
                case { IsValueType: true }:
                {
                    var attrName = GetXmlAttrName(prop);
                    var xmlAttr = xmlObject.Attributes().FirstOrDefault(x => x.Name == attrName);

                    var value = GetValueFromValueType(xmlAttr, prop);
                    prop.SetValue(this, value ?? prop.GetValue(this), null);

                    break;
                }
                default: throw new NotImplementedException($"Type {prop.PropertyType} from {prop} not support");
            }
        }
    }

    private static object? GetValueFromValueType(XAttribute? xmlAttr, PropertyInfo prop)
    {
        var underlyingType = Nullable.GetUnderlyingType(prop.PropertyType);
        var isNullable = underlyingType != null;
        var type = underlyingType ?? prop.PropertyType;

        var result = xmlAttr?.Value switch
        {
            null when isNullable => null,
            { } value when typeof(Guid) == type => TypeDescriptor.GetConverter(type).ConvertFromInvariantString(value),
            { } value when typeof(bool) == type => value switch
            {
                _ when string.IsNullOrEmpty(value) => default,
                "1" => true,
                "0" => false,
                _ when bool.TryParse(value, out var boolResult) => boolResult,
                _ => default
            },
            { } value when type.IsEnum => EnumConvertor(value, type),
            _ => xmlAttr?.Value is null ? null : Convert.ChangeType(xmlAttr.Value, type)
        };

        return result;
    }
    
    private static object? GetValueFromRefType(XNode? xmlProp, PropertyInfo prop)
    {
        if (xmlProp is null) return null;
        using var propReader = xmlProp.CreateReader();
        var serializer = new XmlSerializer(prop.PropertyType);
        return serializer.Deserialize(propReader);
    }
    
    private static object? GetValueFromEnumerableType(List<XElement> xmlElements, PropertyInfo prop)
    {
        if (!xmlElements.Any()) return null;

        var sb = new StringBuilder();
        var type = typeof(EnumerableWrapper<>).MakeGenericType(prop.PropertyType);

        sb.AppendLine($"<{nameof(EnumerableWrapper<object>.Items)}>");
        foreach (var xmlProp in xmlElements)
            sb.AppendLine(xmlProp.ToString());
        sb.AppendLine($"</{nameof(EnumerableWrapper<object>.Items)}>");

        using var arrayXmlReader = new StringReader(sb.ToString());

        var overrides = new XmlAttributeOverrides();
        overrides.Add(type, nameof(EnumerableWrapper<object>.Items), new XmlAttributes()
        {
            XmlElements =
            {
                new XmlElementAttribute()
                {
                    ElementName = xmlElements[0].Name.LocalName,
                }
            }
        });

        var serializer = GetXmlSerializer(type, overrides);

        var result = serializer.Deserialize(arrayXmlReader);
        return result is null
            ? null
            : type.GetProperty(nameof(EnumerableWrapper<object>.Items))!.GetValue(result, null);
    }

    private static object EnumConvertor(object? value, Type type)
    {
        if (value is string s)
            value = Enum.Parse(type, s, true);

        value = Enum.ToObject(type, Convert.ToUInt64(value));

        if (!Enum.IsDefined(type, value))
            throw new InvalidCastException($"Cannot cast {value} to enum type {type.Name}.");

        return value;
    }
    
    private static XmlSerializer GetXmlSerializer(Type type, XmlAttributeOverrides attributeOverrides)
    {
        var key =
            $"{type.FullName!}-{attributeOverrides[type, nameof(EnumerableWrapper<object>.Items)].XmlElements[0].ElementName}"
                .GetHashCode();
        
        if (SerializerCache.TryGetValue(key, out var serializer)) return serializer;
        serializer = new XmlSerializer(type, attributeOverrides);
        SerializerCache.AddOrUpdate(key, x => serializer, (i, xmlSerializer) => serializer);
        return serializer;
    }
    
    private static bool IsEnumerableType(Type type)
    {
        return type.Name != nameof(String)
               && type.GetInterface(nameof(IEnumerable)) != null;
    }

    protected virtual string GetXmlElementName(PropertyInfo prop)
    {
        var xmlElement =
            prop.GetCustomAttributes(typeof(XmlElementAttribute), true).FirstOrDefault() as XmlElementAttribute;

        return xmlElement?.ElementName ?? prop.Name;
    }

    protected virtual string GetXmlAttrName(PropertyInfo prop)
    {
        var xmlAttribute =
            prop.GetCustomAttributes(typeof(XmlAttributeAttribute), true).FirstOrDefault() as XmlAttributeAttribute;

        return xmlAttribute?.AttributeName ?? prop.Name;
    }

    public virtual XmlSchema GetSchema() => throw new NotImplementedException();
    public virtual void WriteXml(XmlWriter writer) => throw new NotImplementedException();
}

[XmlRoot(nameof(Items))]
public class EnumerableWrapper<T>
{
    public T Items { get; set; }
}

然后，您只需从xmlnullableserializable即可继承您的类。
这仅适用于绝对化，您的类可以包含类型结构的可随机字段。
例子：

public class A : XmlNullableSerializable
{
    public int Int {get;set;}
    public bool? Bool {get;set;}
}

public class B : XmlNullableSerializable
{
    public A Obj {get;set;}
    public List<A> Enumerable {get;set;}
    public DateTime? Dt {get;set;}
}

var xml = "...";
using var sr = new StringReader(xml);
var serializer = new XmlSerializer(typeof(B));
var obj = serializer.Deserialize(sr);

Answer 8

提供一个非常简单的解决方案，该解决方案适用于双打或其他价值类型，以使用可能的值之一（double.nan）为代价。它仅需要内置的序列化*（）属性（无需额外的备份字段）。

public class Elem2D
{
    [XmlAttribute("sx")]
    public double StartX = double.NaN;

    [XmlAttribute("ex")]
    public double EndX;

    public bool ShouldSerializeStartX() => !double.IsNaN(StartX);
}

到达上述情况，因为无效的价值类型在序列化到[XMLATTRIBUTES]时会引起异常，并且添加额外的属性似乎太多了。 XMLSerializer支持公共字段或属性，属性确实支持初始化器，因此当然，如果这是您的最佳实践，请使用属性。因为整数可以使用int.maxvalue如果您的域不需要。