反序列化动态JSON文件C#NewtonSoft.JSON [英] Deserialize Dynamic JSON file C# NewtonSoft.JSON
问题描述
在反序列化可能包含2个单独的类,我不知道哪种类型的数据将是阵列中的动态JSON文件的工作。
问题是我反序列化根对象键入基地,测验对象序列化,以分测验,但测验数组可能是类型的基地或类型的子测试。
问:
我怎么会去编程判断,如果对象包含分测验,我反序列化基地,如果没有,就应该反序列化到分测验?
我真的很感激这一个,因为我在很短的时间线中的帮助。
(编辑:添加注释,以显示每一个对象应该反序列化到什么类型)
下面是一个例子(JSON数据):
{
//反序列化键入基地
主人:123456,
:LAST_TIMEBREAK:2014年9月15日07:04:49.205000 ,
名:MYNAME,
结果:不及格,
系列:12345,
START_TIME:2014-09- 15 06:53:36.976000,
//反序列化到类型列表<&子测试GT;
测验:[
{
数据:{
MOREDATA:{
版本:123,
实:123
}
},
说明:数据说明,
主人:123456,
:LAST_TIMEBREAK:2014 -09-15 20:32:31.095000,
名:testname.py,
结果:PASS,
START_TIME:2014-09- 15 20:32:25.873000,
版本:2.014.09.15
},
{
//嵌套子测试阵列中,应反序列化键入基地再次
主人:123456,
:LAST_TIMEBREAK:2014年9月15日07:04:49.205000,
名:测试套件的名称,
结果:不及格,
START_TIME:2014年9月15日06:53:36.976000,
//应该反序列化为类型列表<&子测试GT;
测验:[
{
说明:数据说明,
主人:123456,
:LAST_TIMEBREAK:2014 -09-15 06:53:40.440000,
名:testname.py,
结果:不及格,
START_TIME:2014-09- 15 06:53:36.976000,
版本:2.014.09.15
},
{
说明:考试说明,
举办:123456,
:LAST_TIMEBREAK:2014年9月15日06:54:34.905000,
名:testname.py,
结果: PASS,
START_TIME:2014年9月15日06:54:34.827000,
版本:2.014.09.15
},
$ { b $ b主人:123456,
:LAST_TIMEBREAK:2014年9月15日06:55:01.156000,
名:testname.py,
结果:FAIL,
START_TIME:2014年9月15日06:55:01.156000,
版本:2.014.09.15
},
],
版本:1.45
}
],
版本:1.23
}
示例(代码):
公共类基地{
公共字符串主机{搞定;组; }
公众的DateTime:LAST_TIMEBREAK {搞定;组; }
公共字符串名称{;组; }
公共字符串结果{搞定;组; }
公共字符串序列{搞定;组; }
公众的DateTime START_TIME {搞定;组; }
公开名单<&子测试GT;测验{搞定;组; }
公共字符串版本{搞定;组; }
}
公共类子测试{
[JsonProperty(数据)]
公共JObject数据{搞定;组; } //检查
[JsonProperty(说明)]
公共字符串描述{搞定;组; } //检查
[JsonProperty(主机)]
公共字符串主机{搞定;组; }
[JsonProperty(信息)
公开名单< StatusDetails>信息{搞定;组; }
[JsonProperty(:LAST_TIMEBREAK)]
公众的DateTime LastRunTime {搞定;组; }
[JsonProperty(名称)]
公共字符串测试名{获得;组; }
[JsonProperty(结果)]
公共字符串SubtestRunResult {搞定;组; }
[JsonProperty(START_TIME)]
公共DateTime的开始时间{搞定;组; }
[JsonProperty(跟踪)]
公开名单<对象>跟踪{搞定;组; }
[JsonProperty(版本)]
公共字符串版本{搞定;组; }
}
我要返工你的类以形成一个分层结构。我可能在这里缺少一个属性,但你得到的图片。 。最重要的一点是转换器
公共抽象类TestBase
{
公共字符串主机{搞定;组; }
[JsonProperty(:LAST_TIMEBREAK)]
公众的DateTime LastTime {搞定;组; }
公共字符串名称{;组; }
公共字符串结果{搞定;组; }
[JsonProperty(START_TIME)]
公共DateTime的开始时间{搞定;组; }
公共字符串版本{搞定;组; }
}
公共类的TestSuite:TestBase
{
公共字符串序列{搞定;组; }
公开名单< TestBase>测验{搞定;组; }
}
公共类子测试:TestBase
{
公共JObject数据{搞定;组; }
公共字符串描述{搞定;组; }
}
然后,你需要一个自定义的转换器来选择基础上,正确的类型
公共类TestBaseConverter:JsonConverter $ b中的测验
属性的存在$ b {
公众覆盖对象ReadJson(
JsonReader读者,
类型的objectType,
对象existingValue,
JsonSerializer串行)
{
JObject OBJ = serializer.Deserialize< JObject>(读卡器);
TestBase结果= NULL;
如果(OBJ [测验]!= NULL)
{
结果=新的TestSuite();
}
,否则
{
结果=新的子测试();
}
serializer.Populate(obj.CreateReader(),结果);
返回结果;
}
公众覆盖布尔CanConvert(类型的objectType)
{
返回的typeof(TestBase).IsAssignableFrom(的objectType);
}
公众覆盖布尔CanWrite
{
获得{返回false; }
}
公共覆盖无效WriteJson(
JsonWriter作家,对象的值,JsonSerializer串行)
{
抛出新NotSupportedException异常();
}
}
您会然后使用它是这样的:
的TestSuite套件= JsonConvert.DeserializeObject<&TestSuite的GT;(
JSON,新TestBaseConverter());
Working on deserializing a dynamic JSON file which could contain 2 separate classes and I won't know which type of data will be in the array.
The problem is, I deserialize the root object to type "Base", "subtests" objects are deserialized to "Subtest", but the "subtests" array could be of type "Base" or of type "Subtest".
QUESTION: How would I go about programatically determining that if the object contains "subtest", I deserialize to Base, and if it doesn't, it should deserialize to "Subtest"?
I really appreciate the help on this one since I'm on a short timeline.
(EDIT: Added comments to show what type each object should deserialize to) Here's an example (JSON DATA):
{
// Deserializes to type "Base"
"host": "123456",
"last_time": "2014-09-15 07:04:49.205000",
"name": "myName",
"result": "FAIL",
"serial": "12345",
"start_time": "2014-09-15 06:53:36.976000",
// Deserializes to type "List<Subtest>"
"subtests": [
{
"data": {
"moredata": {
"ver": "123",
"real": 123
}
},
"description": "Description of Data",
"host": "123456",
"last_time": "2014-09-15 20:32:31.095000",
"name": "testname.py",
"result": "PASS",
"start_time": "2014-09-15 20:32:25.873000",
"version": "2.014.09.15"
},
{
// Nested within Subtest Array, Should deserialize to type "Base" again
"host": "123456",
"last_time": "2014-09-15 07:04:49.205000",
"name": "name of test suite",
"result": "FAIL",
"start_time": "2014-09-15 06:53:36.976000",
//Should deserialize to type "List<Subtest>"
"subtests": [
{
"description": "Description of Data",
"host": "123456",
"last_time": "2014-09-15 06:53:40.440000",
"name": "testname.py",
"result": "FAIL",
"start_time": "2014-09-15 06:53:36.976000",
"version": "2.014.09.15"
},
{
"description": "Test Description",
"host": "123456",
"last_time": "2014-09-15 06:54:34.905000",
"name": "testname.py",
"result": "PASS",
"start_time": "2014-09-15 06:54:34.827000",
"version": "2.014.09.15"
},
{
"host": "123456",
"last_time": "2014-09-15 06:55:01.156000",
"name": "testname.py",
"result": "FAIL",
"start_time": "2014-09-15 06:55:01.156000",
"version": "2.014.09.15"
},
],
"version": "1.45"
}
],
"version": "1.23"
}
Example (CODE):
public class Base{
public string host { get; set; }
public DateTime last_time { get; set; }
public string name { get; set; }
public string result { get; set; }
public string serial { get; set; }
public DateTime start_time { get; set; }
public List<Subtest> subtests { get; set; }
public string version { get; set; }
}
public class Subtest {
[JsonProperty("data")]
public JObject Data { get; set; } // CHECK
[JsonProperty("description")]
public string Description { get; set; } // CHECK
[JsonProperty("host")]
public string Host { get; set; }
[JsonProperty("info")]
public List<StatusDetails> Info { get; set; }
[JsonProperty("last_time")]
public DateTime LastRunTime { get; set; }
[JsonProperty("name")]
public string TestName { get; set; }
[JsonProperty("result")]
public string SubtestRunResult { get; set; }
[JsonProperty("start_time")]
public DateTime StartTime { get; set; }
[JsonProperty("trace")]
public List<object> Trace { get; set; }
[JsonProperty("version")]
public string Version { get; set; }
}
I would rework your classes to form a hierarchy. I'm probably missing a properties here, but you get the picture. The important bit is the converter.
public abstract class TestBase
{
public string Host { get; set; }
[JsonProperty("last_time")]
public DateTime LastTime { get; set; }
public string Name { get; set; }
public string Result { get; set; }
[JsonProperty("start_time")]
public DateTime StartTime { get; set; }
public string Version { get; set; }
}
public class TestSuite : TestBase
{
public string Serial { get; set; }
public List<TestBase> Subtests { get; set; }
}
public class Subtest : TestBase
{
public JObject Data { get; set; }
public string Description { get; set; }
}
Then, you need a custom converter to choose the correct type based on the existence of the subtests
property:
public class TestBaseConverter : JsonConverter
{
public override object ReadJson(
JsonReader reader,
Type objectType,
object existingValue,
JsonSerializer serializer)
{
JObject obj = serializer.Deserialize<JObject>(reader);
TestBase result = null;
if (obj["subtests"] != null)
{
result = new TestSuite();
}
else
{
result = new Subtest();
}
serializer.Populate(obj.CreateReader(), result);
return result;
}
public override bool CanConvert(Type objectType)
{
return typeof(TestBase).IsAssignableFrom(objectType);
}
public override bool CanWrite
{
get { return false; }
}
public override void WriteJson(
JsonWriter writer, object value, JsonSerializer serializer)
{
throw new NotSupportedException();
}
}
You would then use it like this:
TestSuite suite = JsonConvert.DeserializeObject<TestSuite>(
json, new TestBaseConverter());
这篇关于反序列化动态JSON文件C#NewtonSoft.JSON的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!