Question

使用从XSD文档生成的C＃类，我可以创建一个对象，并成功序列化它。但是，某些属性定义了XmlDefaultValue。如果任何对象具有默认值，则在序列化对象时不会创建这些属性。

根据documentation，这是预期的行为。但这不是我希望它表现的方式。我需要在XML文档中生成所有这些属性我已检查过任何可能会强制输出的代码属性，即使它是默认值，但我也找不到类似的东西。

有没有办法让这项工作？

Answer 1

您可以在序列化时为特定的一组类型执行此操作，方法是为每个已应用DefaultValueAttribute的字段或属性构建XmlAttributeOverrides，然后将其传递给{ {3}}构造函数：

    var overrides = new XmlAttributeOverrides();
    var attrs = new XmlAttributes() { XmlDefaultValue = null };

    overrides.Add(typeToSerialize, propertyNameWithDefaultToIgnore, attrs);
    var serializer = new XmlSerializer(typeToSerialize, overrides);

但请注意，new XmlAttributes() { XmlDefaultValue = null }：

动态生成的程序集

为了提高性能，XML序列化基础结构动态生成程序集以序列化和反序列化指定的类型。基础结构查找并重用这些程序集。仅当使用以下构造函数时才会出现此问题：

XmlSerializer.XmlSerializer（类型）：

XmlSerializer.XmlSerializer（Type，String）

如果使用任何其他构造函数，则会生成同一程序集的多个版本，并且永远不会卸载，这会导致内存泄漏和性能下降。最简单的解决方案是使用前面提到的两个构造函数之一。否则，必须将程序集缓存在Hashtable中，如以下示例所示。

但是，代码中给出的示例并未提供如何键入哈希表的任何建议。它也不是线程安全的。（也许它的历史可以从.Net 1.0开始？）

以下代码为带有覆盖的xml序列化程序创建一个密钥方案，并制造（通过反射）序列化程序，所有属性和字段的[DefaultValue]值（如果有）被覆盖为null，从而有效地取消默认值：

public abstract class XmlSerializerKey
{
    static class XmlSerializerHashTable
    {
        static Dictionary<object, XmlSerializer> dict;

        static XmlSerializerHashTable()
        {
            dict = new Dictionary<object, XmlSerializer>();
        }

        public static XmlSerializer GetSerializer(XmlSerializerKey key)
        {
            lock (dict)
            {
                XmlSerializer value;
                if (!dict.TryGetValue(key, out value))
                    dict[key] = value = key.CreateSerializer();
                return value;
            }
        }
    }

    readonly Type serializedType;

    protected XmlSerializerKey(Type serializedType)
    {
        this.serializedType = serializedType;
    }

    public Type SerializedType { get { return serializedType; } }

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(this, obj))
            return true;
        else if (ReferenceEquals(null, obj))
            return false;
        if (GetType() != obj.GetType())
            return false;
        XmlSerializerKey other = (XmlSerializerKey)obj;
        if (other.serializedType != serializedType)
            return false;
        return true;
    }

    public override int GetHashCode()
    {
        int code = 0;
        if (serializedType != null)
            code ^= serializedType.GetHashCode();
        return code;
    }

    public override string ToString()
    {
        return string.Format(base.ToString() + ": for type: " + serializedType.ToString());
    }

    public XmlSerializer GetSerializer()
    {
        return XmlSerializerHashTable.GetSerializer(this);
    }

    protected abstract XmlSerializer CreateSerializer();
}

public abstract class XmlserializerWithExtraTypesKey : XmlSerializerKey
{
    static IEqualityComparer<HashSet<Type>> comparer;

    readonly HashSet<Type> extraTypes = new HashSet<Type>();

    static XmlserializerWithExtraTypesKey()
    {
        comparer = HashSet<Type>.CreateSetComparer();
    }

    protected XmlserializerWithExtraTypesKey(Type serializedType, IEnumerable<Type> extraTypes)
        : base(serializedType)
    {
        if (extraTypes != null)
            foreach (var type in extraTypes)
                this.extraTypes.Add(type);
    }

    public Type[] ExtraTypes { get { return extraTypes.ToArray(); } }

    public override bool Equals(object obj)
    {
        if (!base.Equals(obj))
            return false;
        XmlserializerWithExtraTypesKey other = (XmlserializerWithExtraTypesKey)obj;
        return comparer.Equals(this.extraTypes, other.extraTypes);
    }

    public override int GetHashCode()
    {
        int code = base.GetHashCode();
        if (extraTypes != null)
            code ^= comparer.GetHashCode(extraTypes);
        return code;
    }
}

public sealed class XmlSerializerIgnoringDefaultValuesKey : XmlserializerWithExtraTypesKey
{
    readonly XmlAttributeOverrides overrides;

    private XmlSerializerIgnoringDefaultValuesKey(Type serializerType, IEnumerable<Type> ignoreDefaultTypes, XmlAttributeOverrides overrides)
        : base(serializerType, ignoreDefaultTypes)
    {
        this.overrides = overrides;
    }

    public static XmlSerializerIgnoringDefaultValuesKey Create(Type serializerType, IEnumerable<Type> ignoreDefaultTypes, bool recurse)
    {
        XmlAttributeOverrides overrides;
        Type [] typesWithOverrides;

        CreateOverrideAttributes(ignoreDefaultTypes, recurse, out overrides, out typesWithOverrides);
        return new XmlSerializerIgnoringDefaultValuesKey(serializerType, typesWithOverrides, overrides);
    }

    protected override XmlSerializer CreateSerializer()
    {
        var types = ExtraTypes;
        if (types == null || types.Length < 1)
            return new XmlSerializer(SerializedType);
        return new XmlSerializer(SerializedType, overrides);
    }

    static void CreateOverrideAttributes(IEnumerable<Type> types, bool recurse, out XmlAttributeOverrides overrides, out Type[] typesWithOverrides)
    {
        HashSet<Type> visited = new HashSet<Type>();
        HashSet<Type> withOverrides = new HashSet<Type>();
        overrides = new XmlAttributeOverrides();

        foreach (var type in types)
        {
            CreateOverrideAttributes(type, recurse, overrides, visited, withOverrides);
        }

        typesWithOverrides = withOverrides.ToArray();
    }

    static void CreateOverrideAttributes(Type type, bool recurse, XmlAttributeOverrides overrides, HashSet<Type> visited, HashSet<Type> withOverrides)
    {
        if (type == null || type == typeof(object) || type.IsPrimitive || type == typeof(string) || visited.Contains(type))
            return;
        var attrs = new XmlAttributes() { XmlDefaultValue = null };
        foreach (var property in type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public))
            if (overrides[type, property.Name] == null) // Check to see if overrides for this base type were already set.
                if (property.GetCustomAttributes<DefaultValueAttribute>(true).Any())
                {
                    withOverrides.Add(type);
                    overrides.Add(type, property.Name, attrs);
                }
        foreach (var field in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public))
            if (overrides[type, field.Name] == null) // Check to see if overrides for this base type were already set.
                if (field.GetCustomAttributes<DefaultValueAttribute>(true).Any())
                {
                    withOverrides.Add(type);
                    overrides.Add(type, field.Name, attrs);
                }
        visited.Add(type);
        if (recurse)
        {
            var baseType = type.BaseType;
            if (baseType != type)
                CreateOverrideAttributes(baseType, recurse, overrides, visited, withOverrides);
        }
    }
}

然后你会这样称呼：

var serializer = XmlSerializerIgnoringDefaultValuesKey.Create(typeof(ClassToSerialize), new[] { typeof(ClassToSerialize), typeof(AdditionalClass1), typeof(AdditionalClass2), ... }, true).GetSerializer();

例如，在以下类层次结构中：

public class BaseClass
{
    public BaseClass() { Index = 1; }
    [DefaultValue(1)]
    public int Index { get; set; }
}

public class MidClass : BaseClass
{
    public MidClass() : base() { MidDouble = 1.0; }
    [DefaultValue(1.0)]
    public double MidDouble { get; set; }
}

public class DerivedClass : MidClass
{
    public DerivedClass() : base() { DerivedString = string.Empty; }
    [DefaultValue("")]
    public string DerivedString { get; set; }
}

public class VeryDerivedClass : DerivedClass
{
    public VeryDerivedClass() : base() { this.VeryDerivedIndex = -1; }
    [DefaultValue(-1)]
    public int VeryDerivedIndex { get; set; }
}

默认XmlSerializer会产生：

<VeryDerivedClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" />

但是自定义序列化程序会生成

<?xml version="1.0" encoding="utf-16"?>
<VeryDerivedClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <Index>1</Index>
    <MidDouble>1</MidDouble>
    <DerivedString />
    <VeryDerivedIndex>-1</VeryDerivedIndex>
</VeryDerivedClass>

最后请注意，空值的写入由XmlSerializer(Type, XmlAttributeOverrides)控制，因此空序列的写入不受此序列化程序的影响。

Answer 2

关于DataContract的最后答案不是答案。 XSD是自动生成的，消费类的人不能控制原作者使用的属性。问题是关于基于XSD的自动生成的类。

另一个答案也存在问题，因为定义了默认值的属性也可能不允许空值（这种情况经常发生）。唯一真正的解决方案是使用序列化程序，您可以告诉它在序列化方面要忽略哪些属性。对于当前的XML序列化程序来说，这一直是一个严重的问题，它根本不允许传递哪些属性来强制序列化。

实际情况：

REST服务接受正文中的XML来更新对象。 XML具有由其余服务的作者定义的XSD。休息服务存储的当前对象具有非默认值集。用户修改XML以将其更改回默认值...但是在REST帖子的主体中放置的序列化版本会跳过该值并且不会包含它，因为它设置为默认值。

多么糟糕......无法更新值，因为不导出默认值的逻辑完全忽略了XML可用于更新对象的想法，而不仅仅是基于XML创建新对象。我无法相信这已经很多年了，没有人修改过XML序列化程序来轻松处理这个基本场景。

Answer 3

我找到了答案： https://msdn.microsoft.com/en-us/library/system.runtime.serialization.datamemberattribute.emitdefaultvalue%28v=vs.110%29.aspx

在DataContract中设置属性，如下所示：[DataMember（EmitDefaultValue = true）]

强制XmlDefaultValue值的XML序列化

3 个答案: