JsonConvert.DeserializeObject를 사용하여 파생 개체의 목록을 역 직렬화하는

Question

나는 내가 JSON으로 API에서 보내는이 Object

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

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

를하고 난 내 클라이언트 응용 프로그램에서 역 직렬화. 내가없는 것

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(); 
    } 
}