Question

我正在尝试序列化/反序列化复杂类型。我希望保留对象引用，这意味着如果在对象图中多次引用对象的实例，则在反序列化期间，我希望反序列化器仅创建该实例一次并多次引用它（与创建该对象实例相比）多次）。

我需要系统处理的第二件事是字典，其中键本身就是一个复杂的类型。

我能够通过DataContractSerializer序列化到XML来实现这两个目标。但是，我没有找到任何可以执行此操作的Json序列化程序。我尝试过Json.NET和ServiceStack，但没有运气。

请参阅下面的示例代码：

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Xml;
using Newtonsoft.Json;

namespace Serialization
{
    class Program
    {

        static void Main(string[] args)
        {
            var transportModel = CreateSampleModel();


            //Serialize with DataContractSerializer
            var serializer = new DataContractSerializer(typeof(TransportModel), null, int.MaxValue, false, true, null, null);
            string serializedObjectXml;
            using (var sw = new StringWriter())
            {
                using (var writer = new XmlTextWriter(sw))
                {
                    serializer.WriteObject(writer, transportModel);
                    writer.Flush();
                    serializedObjectXml = sw.ToString();
                }
            }

            //Deserialize with DataContractSerializer
            byte[] byteArray = Encoding.ASCII.GetBytes(serializedObjectXml);
            var stream = new MemoryStream(byteArray);
            var deserializedObjectXml = serializer.ReadObject(stream);


            //Serialize with Json.NET
            var serializedObjectJson=JsonConvert.SerializeObject(transportModel);

            //Deserialize with Json.NET - this fails because of the key in the dictionary being a complex type
            var deserializedObjectJson = JsonConvert.DeserializeObject(serializedObjectJson);
        }


        static TransportModel CreateSampleModel()
        {
            var transportModel = new TransportModel();

            // dests
            var fra = new Destination
            {
                Id = 0,
                Name = "FRA",
                Demand = 900
            };
            var det = new Destination
            {
                Id = 1,
                Name = "DET",
                Demand = 1200
            };


            var dests = new List<Destination> { fra, det};

            //origs
            var gary = new Origin
            {
                Id = 0,
                Name = "GARY",
                Supply = 1400,
                Cost = new Dictionary<Destination, int>{
                    {fra, 39},
                    {det, 14}
                }
            };


            var origs = new List<Origin> { gary};

            transportModel.Destinations = dests;
            transportModel.Origins = origs;

            return transportModel;
        }
    }

    [DataContract]
    class Destination
    {
        [DataMember]
        public int Id { get; set; }
        [DataMember]
        public string Name { get; set; }
        [DataMember]
        public int Demand { get; set; }
    }

    [DataContract]
    class Origin
    {
        [DataMember]
        public int Id { get; set; }
        [DataMember]
        public string Name { get; set; }
        [DataMember]
        public int Supply { get; set; }
        [DataMember]
        public Dictionary<Destination, int> Cost { get; set; }
    }

    [DataContract]
    class TransportModel
    {
        [DataMember]
        public List<Origin> Origins;
        [DataMember]
        public List<Destination> Destinations;

        public TransportModel()
        {
            Origins = new List<Origin>();
            Destinations = new List<Destination>();
        }
    }
}

Answer 1

Json.NET支持处理对象引用：Preserving Object References

复杂类型字典键可以通过创建TypeConverter来处理，该{{3}}将字符串转换为字符串。 Json.NET将使用该字符串作为字典键。

Answer 2

使用.NET内置的BinaryFormatter，它可以保留引用。

虽然我个人不鼓励使用具有循环依赖性的对象图blob，但这种blob不可修改，内省并且几乎没有机会处理版本更改。

数据传输对象（即用于序列化的类型）理想情况下应该是流行的，可版本化的和容忍格式的干净，自我描述和序列化。

使用具有复杂类型作为键的对象引用和字典将复杂类型序列化/反序列化为Json

2 个答案: