我有一个只有一个字段的不可变结构:

struct MyStruct
{
    private readonly double number;

    public MyStruct(double number)
        => this.number = number;
}

我希望它能够通过以下方式序列化/反序列化:

• 数据契约序列化器
• 二进制格式化程序
• XML 序列化程序(编辑:在原始问题中忘记了)
• Json.NET(不添加 Json.NET 作为依赖项)

所以结构变成了这样:

[Serializable]
struct MyStruct : ISerializable, IXmlSerializable
{
    private readonly double number;

    public MyStruct(double number)
        => this.number = number;

    private MyStruct(SerializationInfo info, StreamingContext context)
        => this.number = info.GetDouble(nameof(this.number));

    void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
        => info.AddValue(nameof(this.number), this.number);

    XmlSchema IXmlSerializable.GetSchema() => null;

    void IXmlSerializable.ReadXml(XmlReader reader)
    {
        // Necessary evil
        reader.Read();
        this = new MyStruct(double.Parse(reader.Value, CultureInfo.InvariantCulture));
    }

    void IXmlSerializable.WriteXml(XmlWriter writer)
        => writer.WriteString(this.number.ToString(CultureInfo.InvariantCulture));
}

因为:

• [Serializable] 是二进制格式化程序所必需的。
• Json.NET 同时支持 [DataContract] 和 ISerializable。
• [DataContract] 和 ISerializable 不能一起使用。
• 幸运的是，数据协定序列化程序支持 IXmlSerializer。

C# 7.2 为结构和 MyStruct 引入了 readonly 修饰符，作为不可变结构似乎是一个理想的选择。

问题是 IXmlSerializable 接口(interface)需要改变 MyStruct 的能力。这就是我们上面所做的，分配给 IXmlSerializable.ReadXml 实现中的 this。

readonly struct MyStruct : IXmlSerializable
{
    // ...
    void IXmlSerializable.ReadXml(XmlReader reader)
    {
        // No longer works since "this" is now readonly.
        reader.Read();
        this = new MyStruct(double.Parse(reader.Value, CultureInfo.InvariantCulture));
    }
    // ...
}

我尝试通过反射作弊，但是 FieldInfo.SetValue 将值框起来，而 FieldInfo.SetValueDirect 需要一个 TypedReference，我不能这样做obtain 因为 __makeref 在 this 是只读的时候也是被禁止的。

那么，有哪些方法可以让 MyStruct 被 XML 序列化程序序列化？

我还应该提到，我不关心输出 XML 是什么样子，我真的不需要 IXmlSerializable 接口(interface)提供的细粒度控制。我只需要使用我列出的序列化程序使 MyClass 始终可序列化。

最佳答案

要满足您的要求，您只需要:

[Serializable]
[DataContract]
public readonly struct MyStruct {
    [DataMember]
    private readonly double number;

    public MyStruct(double number)
        => this.number = number;
}

测试代码:

var target = new MyStruct(2);
// with Data Contract serializer
using (var ms = new MemoryStream()) {
    var s = new DataContractSerializer(typeof(MyStruct));
    s.WriteObject(ms, target);
    ms.Position = 0;
    var back = (MyStruct) s.ReadObject(ms);
    Debug.Assert(target.Equals(back));
}

// with Json.NET
var json = JsonConvert.SerializeObject(target);
var jsonBack = JsonConvert.DeserializeObject<MyStruct>(json);
Debug.Assert(target.Equals(jsonBack));

// with binary formatter
using (var ms = new MemoryStream()) {
    var formatter = new BinaryFormatter();
    formatter.Serialize(ms, target);
    ms.Position = 0;
    var back = (MyStruct) formatter.Deserialize(ms);
    Debug.Assert(target.Equals(back));
}

更新。由于您还需要支持XmlSerializer，您可以使用一些不安全的代码来实现您的要求:

[Serializable]    
public readonly struct MyStruct : ISerializable, IXmlSerializable
{        
    private readonly double number;
    public MyStruct(double number)
        => this.number = number;

    private MyStruct(SerializationInfo info, StreamingContext context)
        => this.number = info.GetDouble(nameof(this.number));

    XmlSchema IXmlSerializable.GetSchema() {
        return null;
    }

    unsafe void IXmlSerializable.ReadXml(XmlReader reader) {
        if (reader.Read()) {
            var value = double.Parse(reader.Value, CultureInfo.InvariantCulture);
            fixed (MyStruct* t = &this) {
                *t = new MyStruct(value);
            }
        }
    }

    void IXmlSerializable.WriteXml(XmlWriter writer) {
        writer.WriteString(this.number.ToString(CultureInfo.InvariantCulture));
    }

    public void GetObjectData(SerializationInfo info, StreamingContext context) {
        info.AddValue(nameof(number), this.number);
    }
}

关于c# - 如何使只读结构 XML 可序列化？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47648486/