反序列化动态 JSON

Question

我遇到的问题是如何反序列化以下 JSON。 Answer 的值有时为 NULL、true、整数、布尔值或包含另一个 JSON 列表（id、描述等）。

我做的第一步是在 Visual Studio 中复制并粘贴 special as class。这为我提供了以下问题类。

然后我尝试反序列化它（遵循 C# - rawResponse 是 JSON）。但是，我得到“Newtonsoft.Json.JsonSerializationException：'无法将当前 JSON 数组（例如 [1,2,3]）反序列化为类型 Applicated.Questions，因为该类型需要 JSON 对象（例如 {"name":"value "}) 正确反序列化....“

我知道这与映射不正确有关。

因此，尝试通过将响应保存在动态变量中来将所有这些都放在 foreach 循环中（请注意，我确实为此从 Questions 类中删除了 Property1）。但是，Answer 中的某些结果会将字符串 Id、Description 等存储在 Answer 字段中。有没有更简单的方法，我好像遇到了心理障碍？

JSON：

[
  {
    "Answer": true,
    "QuestionId": 55,
    "Title": "Are you Married?",
    "AnswerType": "Boolean"
  },
  {
    "Answer": {
      "Id": "1",
      "Description": "Female",
      "Reference": "F",
      "ArchiveDate": null,
      "ParentId": null,
      "OptionType": {
        "Id": 40,
        "Type": "dropdown"
      }
    },
    "QuestionId": 778,
    "Title": "Gender",
    "AnswerType": "Option”
  }
]

类：

    public class Questions
    {
        public Class1[] Property1 { get; set; }
    }

    public class Class1
    {
        public object Answer { get; set; }
        public int QuestionId { get; set; }
        public string Title { get; set; }
        public string AnswerType { get; set; }
    }

C#：

Questions result = JsonConvert.DeserializeObject<Questions>(rawResponse);

C# 动态 Foreach

dynamic result = JsonConvert.DeserializeObject(rawResponse);
var lstQuestionObjects = new List<Questions>();

                foreach(var obj in result)
                {
                    lstQuestionObjects.Add(new Questions()
                    {
                        Answer = (obj.Answer !=null) ? obj.Answer.ToString() :"",
                        QuestionId = int.Parse(obj.QuestionId.ToString()),
                        Title = (obj.Title != null) ? obj.Title.ToString() : "",
                        AnswerType = (obj.AnswerType != null) ? obj.AnswerType.ToString() : ""

                    });
                   
                }

Answer 1

这取决于您需要什么级别的互操作性，但首先要认识到的是，在 JSON.Net 中，JSON 文件中的所有 tokens 在内部都继承自 JToken，而不是使用无类型的 object 在您的模型中引用，您将通过将 dynamic 属性键入为 JToken 来获得更好的默认反序列化支持。

这个简单的解决方案在Question 类上显示了一个帮助方法，该方法将答案解析为强类型对象引用。根据您的实施要求，您甚至可能不需要对答案的强类型访问，但是此方法允许您在反序列化完成后对记录值进行后处理和故障排除。

https://dotnetfiddle.net/FwFyOU

List<Question> questions = JsonConvert.DeserializeObject<List<Question>>(GetJSON());
FiddleHelper.WriteTable(questions);

foreach(var question in questions)
{
    object answer = question.GetTypedAnswer();
    Console.WriteLine("Question: [{0}] {1}: ({2}) {3}", question.QuestionId, question.Title, answer.GetType().Name, answer );
}

模型类定义

注意：根本不需要定义名为Questions 的类。

public class Question
{
    public JToken Answer { get; set; }
    public int QuestionId { get; set; }
    public string Title { get; set; }
    public string AnswerType { get; set; }  
    
    public object GetTypedAnswer ()
    {
        switch(AnswerType.ToLower())
        {
            case "boolean":
                return Answer.Value<bool>();
            case "string":
                return Answer.Value<string>();
            case "option":
                return (Answer as JObject).ToObject<Option>();
            default:
                return Answer;
        }
    }
}

public class Option
{
    public string Id { get; set; }
    public string Description { get; set; }
    public string Reference { get; set; }
    public DateTime? ArchiveDate { get; set; }
    public string ParentId { get; set; }
    public OptionType OptionType { get;set; }
    
    public override string ToString()
    {
        return String.Format("[{0}] {1} ({2})", Reference, Description, OptionType.Type);
    }
}
public class OptionType
{
    public int Id { get; set; }
    public string Type { get; set; }        
}

输出：

Answer	QuestionId	Title	AnswerType
True	55	Are you Married?	Boolean
{ "Id": "1", "Description": "Female", "Reference": "F", "ArchiveDate": null, "ParentId": null, "OptionType": { "Id": 40, "Type": "dropdown" } }	778	Gender	Option

Question: [55] Are you Married?: (Boolean) True
Question: [56] What is your name?: (String) Mr John Doe
Question: [778] Gender: (Option) [F] Female (dropdown)

---

另一种解决方案是为Answer 属性使用JsonConverter，但是在这种情况下，解析类型所需的元数据是在父令牌中定义的，而不是在值本身中，这意味着您的自定义转换器将需要通过反复试验来解决类型，如果要比较的类型很多，这可能会非常慢。

折衷方案是为 Question 类本身使用自定义转换器，选择一种方法而不是另一种方法取决于您的需求以及需要解析多少类型（如果需要解析的话）。

https://dotnetfiddle.net/m46NaX

    List<Question> questions = JsonConvert.DeserializeObject<List<Question>>(GetJSON());
    FiddleHelper.WriteTable(questions);
    
    foreach(var question in questions)
    {
        Console.WriteLine("Question: [{0}] {1}: ({2}) {3}", question.QuestionId, question.Title, question.Answer.GetType().Name, question.Answer );
    }

Json 转换器实现

[JsonConverter(typeof(QuestionConverter))]
public class Question
{
    public object Answer { get; set; }
    public int QuestionId { get; set; }
    public string Title { get; set; }
    public string AnswerType { get; set; }  
}

public class QuestionConverter : JsonConverter<Question>
{
    public override Question ReadJson(JsonReader reader, Type objectType, Question existingValue, bool hasExistingValue, JsonSerializer serializer)
    {
        JObject item = JObject.Load(reader);
        var result = new Question();
        result.QuestionId = item.GetValue(nameof(result.QuestionId)).Value<int>();
        result.Title = item.GetValue(nameof(result.Title)).Value<string>();
        result.AnswerType = item.GetValue(nameof(result.AnswerType)).Value<string>();
        
        var answer = item.GetValue(nameof(result.Answer));
        switch(result.AnswerType.ToLower())
        {
            case "boolean":
                result.Answer = answer.Value<bool>();
                break;
            case "string":
                result.Answer =  answer.Value<string>();
                break;
            case "option":
                result.Answer =  (answer as JObject).ToObject<Option>();
                break;
            default:
                result.Answer =  answer;
                break;
        }

        return result;
    }
    
    public override bool CanWrite{ get => false; }
    public override void WriteJson(JsonWriter writer, Question value, JsonSerializer serializer) {  }
}

public class Option
{
    public string Id { get; set; }
    public string Description { get; set; }
    public string Reference { get; set; }
    public DateTime? ArchiveDate { get; set; }
    public string ParentId { get; set; }
    public OptionType OptionType { get;set; }
    
    public override string ToString()
    {
        return String.Format("[{0}] {1} ({2})", Reference, Description, OptionType.Type);
    }
}
public class OptionType
{
    public int Id { get; set; }
    public string Type { get; set; }        
}

Answer 2

看起来你的 json 是数组，所以你需要调用Class1[]:

var result = JsonConvert.DeserializeObject<Class1[]>(rawResponse);

添加实现自定义 AnswerConverter 以反序列化为不同的对象类型：

public class Class1
{
    [JsonConverter(typeof(AnswerConverter))]
    public object Answer { get; set; }
    // ... rest of props
}

---

UPD：如果要根据 AnswerType 属性转换 Answer，则需要 JsonConverter 作为父类型（Class1/Question），而不是 Answer：

void Deserialize()
{
  var questions = JsonConvert.DeserializeObject<Question[]>(rawResponse);
}

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

class QuestionConverter : JsonConverter
{
    public override bool CanRead => true;
    public override bool CanWrite => false;
    public override bool CanConvert(Type objectType) => objectType == typeof(Question);
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { }
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var question = new Question();
        serializer.Populate(reader, question);
        switch (question.AnswerType)
        {
            case "Boolean": break; // already converted to bool by Newtonsoft.Json
            case "Option": question.Answer = ((JObject)question.Answer).ToObject<OptionAnswer>(); break;
            default: throw new NotSupportedException(question.AnswerType);
        }
        return question;
    }
}

[JsonConverter(typeof(QuestionConverter))]
public class Question // Class1 in your example
{
    public int QuestionId { get; set; }
    public string Title { get; set; }
    public string AnswerType { get; set; }
    public object Answer { get; set; }
}
class OptionAnswer
{
    public string Id { get; set; }
    public string Description { get; set; }
    public string Reference { get; set; }
    public string ArchiveDate { get; set; }
    public string ParentId { get; set; }
    public OptionAnswerType OptionType { get; set; }
}
class OptionAnswerType
{
    public int Id { get; set; }
    public string Type { get; set; }
}