反序列化JSON二维值数组

我有一个JSON格式的二维值数组：

[[57, 2], [57, 2], [58, 2], [55, 2], [60, 2], [54, 1], [59, 11]]

每一对实际上包含一对不相关的读数，每分钟一对。因此，在第一分钟，读数1为

57

，读数2为

2

。在第二分钟，读数相同，等等

现在，我想把它转换成一种格式，我可以在.Net中使用它来绘制这些读数。这可以是两个平行阵列，一个用于第一个值的读数，每分钟一个元素，另一个用于第二个值的所有读数。如果这更容易的话，也可以是二维数组

我尝试过使用

DataContractJSONSerializer

，但没有任何运气：

IEnumerable<SubmissionDataRow> obj = (IEnumerable<SubmissionDataRow>)ser.ReadObject(reader, false);

IEnumerable对象=（IEnumerable）ser.ReadObject（reader，false）；

---

其中，

SubmissionDataRow

只是一个类，每个读取都有一个属性，但是反序列化程序不知道在哪个属性中放入什么值

在我使用.NET的时候，它就像一个符咒一样工作。

在我使用.NET的时候，它就像一个符咒一样工作。

你可以通过几种方式使用它。如果您不介意使用二维数字数组，只需将其反序列化为

int[][]

：

string json = "[[57, 2], [57, 2], [58, 2], [55, 2], [60, 2], [54, 1], [59, 11]]";

int[][] values = JsonConvert.DeserializeObject<int[][]>(json);

转换器如下所示：

[JsonConverter(typeof(SubmissionDataRowConverter))]
class SubmissionDataRow
{
    public int Reading1 { get; set; }
    public int Reading2 { get; set; }
}

class SubmissionDataRowConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return (objectType == typeof(SubmissionDataRow));
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JArray array = JArray.Load(reader);
        return new SubmissionDataRow
        {
            Reading1 = array[0].Value<int>(),
            Reading2 = array[1].Value<int>()
        };
    }

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

List<SubmissionDataRow> rows = 
            JsonConvert.DeserializeObject<List<SubmissionDataRow>>(json);

class SubmissionDataRowConverter:JsonConverter
{
公共覆盖布尔CanConvert（类型objectType）
{
返回（objectType==typeof（SubmissionDataRow））；
}
公共重写对象ReadJson（JsonReader阅读器，类型objectType，对象existingValue，JsonSerializer序列化程序）
{
JArray数组=JArray.Load（读卡器）；
返回新的SubmissionDataRow
{
Reading1=数组[0]。值（），
Reading2=数组[1]。值（）
};
}
公共重写void WriteJson（JsonWriter编写器、对象值、JsonSerializer序列化器）
{
抛出新的NotImplementedException（）；
}
}

然后可以像这样反序列化：

[JsonConverter(typeof(SubmissionDataRowConverter))]
class SubmissionDataRow
{
    public int Reading1 { get; set; }
    public int Reading2 { get; set; }
}

class SubmissionDataRowConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return (objectType == typeof(SubmissionDataRow));
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JArray array = JArray.Load(reader);
        return new SubmissionDataRow
        {
            Reading1 = array[0].Value<int>(),
            Reading2 = array[1].Value<int>()
        };
    }

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

List<SubmissionDataRow> rows = 
            JsonConvert.DeserializeObject<List<SubmissionDataRow>>(json);

列出行=
反序列化对象（json）；

您可以通过以下几种方式使用。如果您不介意使用二维数字数组，只需将其反序列化为

int[][]

：

string json = "[[57, 2], [57, 2], [58, 2], [55, 2], [60, 2], [54, 1], [59, 11]]";

int[][] values = JsonConvert.DeserializeObject<int[][]>(json);

转换器如下所示：

[JsonConverter(typeof(SubmissionDataRowConverter))]
class SubmissionDataRow
{
    public int Reading1 { get; set; }
    public int Reading2 { get; set; }
}

class SubmissionDataRowConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return (objectType == typeof(SubmissionDataRow));
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JArray array = JArray.Load(reader);
        return new SubmissionDataRow
        {
            Reading1 = array[0].Value<int>(),
            Reading2 = array[1].Value<int>()
        };
    }

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

List<SubmissionDataRow> rows = 
            JsonConvert.DeserializeObject<List<SubmissionDataRow>>(json);

class SubmissionDataRowConverter:JsonConverter
{
公共覆盖布尔CanConvert（类型objectType）
{
返回（objectType==typeof（SubmissionDataRow））；
}
公共重写对象ReadJson（JsonReader阅读器，类型objectType，对象existingValue，JsonSerializer序列化程序）
{
JArray数组=JArray.Load（读卡器）；
返回新的SubmissionDataRow
{
Reading1=数组[0]。值（），
Reading2=数组[1]。值（）
};
}
公共重写void WriteJson（JsonWriter编写器、对象值、JsonSerializer序列化器）
{
抛出新的NotImplementedException（）；
}
}

然后可以像这样反序列化：

[JsonConverter(typeof(SubmissionDataRowConverter))]
class SubmissionDataRow
{
    public int Reading1 { get; set; }
    public int Reading2 { get; set; }
}

class SubmissionDataRowConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return (objectType == typeof(SubmissionDataRow));
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JArray array = JArray.Load(reader);
        return new SubmissionDataRow
        {
            Reading1 = array[0].Value<int>(),
            Reading2 = array[1].Value<int>()
        };
    }

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

List<SubmissionDataRow> rows = 
            JsonConvert.DeserializeObject<List<SubmissionDataRow>>(json);

列出行=
反序列化对象（json）；