7

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

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

我能够通过将 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>();
        }
    }
}
4

2 回答 2

14

Json.NET 支持处理对象引用：保留对象引用

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

于 2012-07-26T04:25:16.687 回答
0

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

尽管我个人不鼓励使用具有循环依赖关系的对象图 blob，它是不可修改的、可自省的，并且几乎没有机会处理版本控制更改。

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

于 2012-07-25T08:25:43.793 回答