Question

我正在编写一个获取Json对象列表的应用程序，如下所示：

[
   {
       "ObjectType": "apple",
       "ObjectSize": 35,
       "ObjectCost": 4,
       "ObjectTaste": "good",
       "ObjectColor": "golden"
   },
   {
       "ObjectType": "books",
       "ObjectSize": 53,
       "ObjectCost": 7,
       "Pages": 100
   },
   {
       "ObjectType": "melon",
       "ObjectSize": 35,
       "ObjectTaste": "good",
       "ObjectCost": 5
   },
   {
       "ObjectType": "apple",
       "ObjectSize": 29,
       "ObjectCost": 8,
       "ObjectTaste": "almost good",
       "ObjectColor": "red"
   }
  ]

我想创建一个基类ItemToSell（大小，成本），并从中派生Apple，Melon和Book，然后根据“ObjectType”字段对其进行反序列化适合。我希望它构建一个ItemToSell对象列表，每个对象都是Apple，Melon或Book。

我怎么能在.Net中做到这一点？

提前致谢：）

编辑：我知道如何在Big类中反序列化它包含的所有字段，例如：Base(ObjectType,ObjectSize,ObjectCost,ObjectColor,Pages)。但是我希望它能够通过ObjectType来区分类，所以我不会为每个书籍项目的“页面”字段提供任何有用的字段，或者为每本书都有ObjectTaste。

Answer 1

前段时间我遇到了同样的问题。

您可以使用Json.NET，但是如果您无法控制json文档（例如：＆＃39;它已经被其他框架序列化了），那么你＃＆＃39; 39; ll需要像这样创建一个自定义的JsonConverter：

class MyItemConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return typeof(ItemToSell).IsAssignableFrom(objectType);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JObject obj = JObject.Load(reader);
        string discriminator = (string)obj["ObjectType"];

        ItemToSell item;
        switch (discriminator)
        {
            case "apple":
                item = new Apple();
                break;
            case "books":
                item = new Books();
                break;
            case "melon":
                item = new Melon();
                break;
            default:
                throw new NotImplementedException();
        }

        serializer.Populate(obj.CreateReader(), item);

        return item;

    }


    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {

    }
}

然后你需要将它添加到JsonSerializerSettings的转换器中，如下所示：

JsonSerializerSettings settings = new JsonSerializerSettings
{
    TypeNameHandling = TypeNameHandling.Objects,

};
settings.Converters.Add(new MyItemConverter());
var items = JsonConvert.DeserializeObject<List<ItemToSell>>(response, settings);

Answer 2

您可以使用CustomCreationConverter。这使您可以挂钩反序列化过程。

public abstract class Base
{
    public string Type { get; set; }
}

class Foo : Base
{
    public string FooProperty { get; set; }
}

class Bar : Base
{
    public string BarProperty { get; set; }
}

class CustomSerializableConverter : CustomCreationConverter<Base>
{
    public override Base Create(Type objectType)
    {
        throw new NotImplementedException();
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var jObject = JObject.Load(reader);

        var type = (string)jObject.Property("Type");
        Base target;
        switch (type)
        {
            case "Foo":
                target = new Foo();
                break;
            case "Bar":
                target = new Bar();
                break;
            default:
                throw new InvalidOperationException();
        }
        serializer.Populate(jObject.CreateReader(), target);
        return target;
    }
}

class Program
{
    static void Main(string[] args)
    {
        var json = "[{Type:\"Foo\",FooProperty:\"A\"},{Type:\"Bar\",BarProperty:\"B\"}]";
        List<Base> bases = JsonConvert.DeserializeObject<List<Base>>(json, new CustomSerializableConverter());
    }
}

Answer 3

这不是答案，但在C＃6.0中你可以这样做：

  using Microsoft.VisualStudio.TestTools.UnitTesting;
  using Newtonsoft.Json.Linq;
  [TestMethod]
  public void JsonWithDollarOperatorStringIndexers()
  {

      // Additional data types eliminated for elucidation
      string jsonText = @"
        {
          'Byte':  {
            'Keyword':  'byte',
            'DotNetClassName':  'Byte',
            'Description':  'Unsigned integer',
            'Width':  '8',
            'Range':  '0 to 255'
                    },
          'Boolean':  {
            'Keyword':  'bool',
            'DotNetClassName':  'Boolean',
            'Description':  'Logical Boolean type',
            'Width':  '8',
            'Range':  'True or false.'
                      },
        }";
      JObject jObject = JObject.Parse(jsonText);
      Assert.AreEqual("bool", jObject.$Boolean.$Keyword);
    }

取自here.

Answer 4

定义基类和派生类。

使用[JSON.net]（也可通过NuGet获得）1来反序列化它们。

即。

class ItemToSell {
 string Type {get;set;}
 string Size {get;set;}
 string Cost {get;set;}
}

class Book : ItemToSell { ...}

然后使用

反序列化

var catalog = JsonConvert.Deserialize<List<ItemToSell>>(json);

反序列化器将忽略意外的属性。如果需要，可以使用特定类型再次调用它来获取其他属性。

Answer 5

你的班级：

public class RootObject
{
    public string ObjectType { get; set; }
    public int ObjectSize { get; set; }
    public int ObjectCost { get; set; }
    public string ObjectTaste { get; set; }
    public string ObjectColor { get; set; }
    public int? Pages { get; set; }
}

使用NewtonSoft JSON库进行反序列化，如下所示：

var Jsonobject = JsonConvert.DeserializeObject<RootObject>(json);

Answer 6

查看newtonsoft's JSON library

有了它，你可以做类似的事情：

...
public class Movie
{
   public string Name;
   public DateTime ReleaseDate;
   public string[] Genres;
}
......

string json = @"{
  'Name': 'Bad Boys',
  'ReleaseDate': '1995-4-7T00:00:00',
  'Genres': [
    'Action',
    'Comedy'
  ]
}";

Movie m = JsonConvert.DeserializeObject<Movie>(json);

string name = m.Name;
// Bad Boys

基于.Net（C＃）中的字段反序列化json

6 个答案: