如何使用 Newtonsoft 反序列化对象数组的数组

Question

我正在尝试反序列化这样的对象。 我的问题是它正在尝试反序列化内部项目。

{
    "outeritems": [{        
        "inneritems": [
            [{
                "itemid": "1"                
            }, {
                "itemid": "2"                
            }]
        ]
    }]    
}

我已经试过了

public List<List<inneritems>> inneritems{ get; set; }

还有

public List<inneritems> inneritems{ get; set; }

我想这可能需要一个自定义 JSON 转换器

Answer 1

试试这个

public class Inneritem
{
    public String itemid { get; set; }
}

public class Outeritem
{
    public List<Inneritem> inneritems { get; set; }
}

public class RootValue
{
    public List<Outeritem> outeritems { get; set; }
}

Answer 2

实际上，vikas 很接近回答您的问题。

public class Outeritem
    {
        public List<List<object>> inneritems { get; set; }
    }

    public class RootValue
    {
        public List<Outeritem> outeritems { get; set; }
    }

    [TestMethod]
    public void SerializeAndDeserializeTest()
    {
        var expected = "{\"outeritems\":[{\"inneritems\":[[{\"itemid\":\"1\"},{\"itemid\":\"2\"}]]}]}";
        var rootValue = new RootValue
        {
            outeritems = new List<Outeritem>
            {
                new Outeritem
                {
                    inneritems = new List<List<object>> {
                        new List<object> { new {itemid = "1"},new {itemid = "2"} }
                    }
                }
            }
        };

        var actual = JsonConvert.SerializeObject(rootValue);
        Assert.AreEqual(expected, actual);
    }

Answer 3

我必须创建自定义 Newtonsoft JSON 转换器

这就是我所做的。

创建了一个 JsonCreationConverter 基础 Class

public abstract class JsonCreationConverter<T> : JsonConverter
{        
    protected abstract T Create(Type objectType, JObject jObject);

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException("Unnecessary because CanWrite is false. The type will skip the converter.");
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.Null)
            return null;

        JObject jObject = JObject.Load(reader);           

        T target = Create(objectType, jObject);

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

        return target;
    }

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

    public override bool CanWrite
    {
        get { return false; }
    }
}

创建了一个继承了我基础的服装转换器class

public class OuterConverter :
        JsonCreationConverter<OuterItems>
{
        protected override OuterItems Create(Type objectType, JObject jObject)
        {
            OuterItems outeritems =
                new OuterItems();

            var properties = jObject.Properties().ToList();
            outeritems.InnerItems = GetInnerItems((object)properties[0].Value);

            return outeritems;
        }

        // Need to iterate through list so creating a custom object
        private List<List<InnerItems>> GetInnerItems(object propertyValue)
        {

            string sinneritems = "";
            object inneritems = propertyValue;
            sinneritems = String.Format("{0}", inneritems);

            sinneritems = sinneritems.Insert(1, "{ \"Items\": [");
            sinneritems = sinneritems.Substring(1, sinneritems.Length - 1);
            sinneritems = sinneritems.Remove(sinneritems.Length - 1);

            sinneritems += "]}";

            dynamic results = JObject.Parse(sinneritems);

            List<List<InnerItems>> innerItemsList = new List<List<InnerItems>>();

            List<InnerItems> linnerItems = new List<InnerItems>();

            foreach (var items in results.Items)
            {
                foreach (var item in items)
                {
                    string sItem = String.Format("{0}", item);
                    InnerItems ninneritems = Newtonsoft.Json.JsonConvert.DeserializeObject<InnerItems>(sItem);
                    linnerItems.Add(ninneritems);
                }
                innerItemsList.Add(linnerItems);
            }

            return innerItemsList;
        }
}

在 Newtonsoft 解串器上附加新转换器

return Newtonsoft.Json.JsonConvert.DeserializeObject<T>(result.ToString(),
             new OuterConverter());