Question

我有这个对象

public class ConversationAPI
{
    [JsonProperty(PropertyName = "lU")]
    public DateTime LastUpdated { get; set; }

    [JsonProperty(PropertyName = "m", TypeNameHandling = TypeNameHandling.All)]
    public List<Message> Messages { get; set; }
}

我将其作为json从API发送，并在我的客户端应用程序中反序列化。

The List<Message> Messages property contains either 

 [Serializable]
    public class Message
    {
        [JsonProperty(PropertyName = "t")]
        public string Text { get; set; }

        [JsonProperty(PropertyName = "ty")]
        public MessageType Type { get; set; }
    }

或

[Serializable]
    public class DerivedMessage : Message
    {
        [JsonProperty(PropertyName = "sos")]
        public string SomeOtherStuff{ get; set; }
    }

我似乎无法反序列化派生类型的数组。我试过这个

var settings = new JsonSerializerSettings
                    {
                        TypeNameHandling = TypeNameHandling.All,
                        TypeNameAssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Full
                    };
var conversation = JsonConvert.DeserializeObject<ConversationResponse>(response.Content, settings);

我希望列表消息同时包含消息和 DerivedMessage 对象。

有什么想法吗？感谢

Answer 1

找到解决方案。我使用了自定义转换器

public class MessageConverter : JsonCreationConverter<ConversationAPI.Message>
{
    private const string SomeOtherStuffField = "sos";

    protected override ConversationAPI.Message Create(Type objectType, JObject jObject)
    {
        if (FieldExists(SomeOtherStuffField , jObject))
        {
            return new ConversationAPI.DerivedMessage ();
        }

        return new ConversationAPI.Message();
    }

    private bool FieldExists(string fieldName, JObject jObject)
    {
        return jObject[fieldName] != null;
    }
}

public abstract class JsonCreationConverter<T> : JsonConverter
{
    /// <summary>
    /// Create an instance of objectType, based properties in the JSON object
    /// </summary>
    /// <param name="objectType">type of object expected</param>
    /// <param name="jObject">contents of JSON object that will be deserialized</param>
    /// <returns></returns>
    protected abstract T Create(Type objectType, JObject jObject);

    public override bool CanConvert(Type objectType)
    {
        return typeof(T).IsAssignableFrom(objectType);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        // Load JObject from stream
        JObject jObject = JObject.Load(reader);

        // Create target object based on JObject
        T target = Create(objectType, jObject);

        // Populate the object properties
        serializer.Populate(jObject.CreateReader(), target);

        return target;
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

你会像这样使用它：

var jsonText = "{a string of json to convert}"
JsonConverter[] conv = new JsonConverter[] { new MessageConverter() };
var jsonResponse = JsonConvert.DeserializeObject<ConversationAPI>(jsonText, conv);

Answer 2

我花了一些时间测试@Mihai发布的代码。我喜欢这种解决方案，因为它不会更改json文件的内容；序列化照常进行（不添加$type或其他属性）。反序列化通过检查json中是否存在派生字段来确定对象是基础对象还是派生对象。这不是防弹的，但在大多数情况下效果很好。

我必须修复一些语法以使其运行并了解其工作方式。这是修改后的代码，带有有效的用法示例：

using System;
using System.Collections.Generic;
using System.IO;

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace DerivedDeSerJson
{
    [Serializable]
    public class Message
    {
        public string Text { get; set; }
    }

    [Serializable]
    public class DerivedMessage : Message
    {
        public string SomeOtherStuff { get; set; }
    }

    public class ConversationAPI
    {
        public DateTime LastUpdated { get; set; }

        public List<Message> Messages { get; set; }
    }

    public class MessageConverter : JsonCreationConverter<Message>
    {
        private const string SomeOtherStuffField = "SomeOtherStuff";

        protected override Message Create(Type objectType, JObject jObject)
        {
            if (FieldExists(SomeOtherStuffField, jObject))
            {
                return new DerivedMessage();
            }

            return new Message();
        }

        private bool FieldExists(string fieldName, JObject jObject)
        {
            return jObject[fieldName] != null;
        }
    }

    public abstract class JsonCreationConverter<T> : JsonConverter
    {
        /// <summary>
        /// Create an instance of objectType, based properties in the JSON object
        /// </summary>
        /// <param name="objectType">type of object expected</param>
        /// <param name="jObject">contents of JSON object that will be deserialized</param>
        /// <returns></returns>
        protected abstract T Create(Type objectType, JObject jObject);

        public override bool CanConvert(Type objectType)
        {
            return typeof(T).IsAssignableFrom(objectType);
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            // Load JObject from stream
            JObject jObject = JObject.Load(reader);

            // Create target object based on JObject
            T target = Create(objectType, jObject);

            // Populate the object properties
            serializer.Populate(jObject.CreateReader(), target);

            return target;
        }

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            throw new NotImplementedException();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            ConversationAPI conversation = new ConversationAPI()
            {
                LastUpdated = DateTime.Now,
                Messages = new List<Message>()
                {
                   new Message() {Text = "Msg1"},
                   new DerivedMessage() {Text = "Msg2", SomeOtherStuff = "stuff"},
                }
            };
            string jsonText;
            JsonSerializer serializer = new JsonSerializer() { Formatting = Formatting.Indented };
            using (TextWriter text = new StringWriter())
            using (JsonWriter writer = new JsonTextWriter(text))
            {
                serializer.Serialize(writer, conversation);
                jsonText = text.ToString();
            }
            Console.WriteLine(jsonText);
            //Output:
            //{
            //    "LastUpdated": "2020-06-08T17:05:33.7114095+03:00",
            //    "Messages": 
            //    [
            //        { "Text": "Msg1" },
            //        { "SomeOtherStuff": "stuff", "Text": "Msg2" }
            //    ]
            //}

            JsonConverter[] conv = new JsonConverter[] { new MessageConverter() };
            ConversationAPI jsonResponse = JsonConvert.DeserializeObject<ConversationAPI>(jsonText, conv);

            foreach (var msg in jsonResponse.Messages)
            {
                Console.WriteLine(msg.Text);
                Console.WriteLine(msg.ToString());      // Print type name
            }
            //Output:
            // Msg1
            // DerivedDeSerJson.Message
            // Msg2
            // DerivedDeSerJson.DerivedMessage
        }
    }
}

使用JsonConvert.DeserializeObject反序列化派生对象列表

2 个答案: