如何将可序列化的对象序列化为SOAP、Json或Xml

Question

我有一个复杂的对象是可序列化的，我想把它序列化成一个XML文档(节点，我宁愿不改变源代码和添加XML序列化属性的东西)。isserializable可以很好地与BinaryFormatter一起工作，但是没有标准的方法将其序列化为XML或Json。Json。. NET库确实支持将一个可序列化的对象序列化为json，但是这个实现有一个非常小的问题，那就是类的可序列化构造函数应该是公共的，以便Json.net检测到它(见这个问题)，这确实使Json.net无法用于我的情况。

是否有其他方法来序列化/反序列化可序列化对象到/从xml, Json或任何其他平面文本格式?

Answer 1

Json。. NET实际上支持ISerializable类型的非公共流序列化构造函数。请参阅DefaultContractResolver.CreateISerializableContract()的源代码。

你的实际问题是，ISerializable类型的问题也是一个集合，它似乎Json。对于这些类型，NET优先使用数组契约而不是JsonISerializableContract，如DefaultContractResolver.CreateContract()所示:

        if (typeof(IEnumerable).IsAssignableFrom(t))
        {
            return CreateArrayContract(objectType);
        }
        if (CanConvertToString(t))
        {
            return CreateStringContract(objectType);
        }
#if !(DOTNET || PORTABLE40 || PORTABLE)
        if (!IgnoreSerializableInterface && typeof(ISerializable).IsAssignableFrom(t))
        {
            return CreateISerializableContract(objectType);
        }
#endif

要解决这个问题，您可以创建自己的自定义契约解析器来反转这个逻辑:

public class ISerializableCollectionContractResolver : DefaultContractResolver
{
    protected override JsonContract CreateContract(Type objectType)
    {
        var contract = base.CreateContract(objectType);
        var underlyingType = Nullable.GetUnderlyingType(objectType) ?? objectType;
        if (!IgnoreSerializableInterface 
            && typeof(ISerializable).IsAssignableFrom(underlyingType)
            && contract is JsonArrayContract
            && !underlyingType.GetCustomAttributes<JsonContainerAttribute>().Any())
        {
            contract = CreateISerializableContract(objectType);
        }
        return contract;
    }
}

你的自定义集合现在应该通过它们的ISerializable接口序列化。

您可能希望缓存契约解析器以获得最佳性能。

Answer 2

DataContractSerializer和DataContractJsonSerializer都支持ISerializable。请参阅数据契约序列化器支持的类型。

例如，考虑以下类:

[Serializable]
public class SerializableClass : ISerializable
{
    readonly int valueField;
    public SerializableClass(int valueField)
    {
        this.valueField = valueField;
    }
    public int Value { get { return valueField; } }
    #region ISerializable Members
    protected SerializableClass(SerializationInfo info, StreamingContext context)
    {
        this.valueField = info.GetInt32("valueField");
    }
    void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("valueField", valueField);
    }
    #endregion
}

和以下辅助方法:

public static partial class DataContractSerializerHelper
{
    public static string SerializeXml<T>(T obj, DataContractSerializer serializer = null, XmlWriterSettings settings = null)
    {
        serializer = serializer ?? new DataContractSerializer(obj.GetType());
        using (var textWriter = new StringWriter())
        {
            settings = settings ?? new XmlWriterSettings { Indent = true, IndentChars = "    " };
            using (var xmlWriter = XmlWriter.Create(textWriter, settings))
            {
                serializer.WriteObject(xmlWriter, obj);
            }
            return textWriter.ToString();
        }
    }
    public static T DeserializeXml<T>(string xml, DataContractSerializer serializer = null)
    {
        using (var textReader = new StringReader(xml ?? ""))
        using (var xmlReader = XmlReader.Create(textReader))
        {
            return (T)(serializer ?? new DataContractSerializer(typeof(T))).ReadObject(xmlReader);
        }
    }
}
public static partial class DataContractJsonSerializerHelper
{
    private static MemoryStream GenerateStreamFromString(string value)
    {
        return new MemoryStream(Encoding.Unicode.GetBytes(value ?? ""));
    }
    public static string SerializeJson<T>(T obj, DataContractJsonSerializer serializer = null)
    {
        serializer = serializer ?? new DataContractJsonSerializer(obj.GetType());
        using (var memory = new MemoryStream())
        {
            serializer.WriteObject(memory, obj);
            memory.Seek(0, SeekOrigin.Begin);
            using (var reader = new StreamReader(memory))
            {
                return reader.ReadToEnd();
            }
        }
    }
    public static T DeserializeJson<T>(string json, DataContractJsonSerializer serializer = null)
    {
        serializer = serializer ?? new DataContractJsonSerializer(typeof(T));
        using (var stream = GenerateStreamFromString(json))
        {
            var obj = serializer.ReadObject(stream);
            return (T)obj;
        }
    }
}

然后

var test = new SerializableClass(42);
var xml = DataContractSerializerHelper.SerializeXml(test);
Debug.WriteLine(xml);

生产

<SerializableClass xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:x="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.datacontract.org/2004/07/Question38188639">
    <valueField i:type="x:int" xmlns="">42</valueField>
</SerializableClass>

和

var json = DataContractJsonSerializerHelper.SerializeJson(test);
Debug.WriteLine(json);

生产

{"valueField":42}