30

我有一个自定义集合（实现 IList），它有一些自定义属性，如下所示：

class FooCollection : IList<Foo> {

    private List<Foo> _foos = new List<Foo>();
    public string Bar { get; set; }        

    //Implement IList, ICollection and IEnumerable members...

}

当我序列化时，我使用以下代码：

JsonSerializerSettings jss = new JsonSerializerSettings() {
    TypeNameHandling = TypeNameHandling.Auto
};
string serializedCollection = JsonConvert.SerializeObject( value , jss );

它正确地序列化和反序列化所有集合项；FooCollection但是，不考虑类中的任何额外属性。

反正有没有将它们包含在序列化中？

4

6 回答 6

29

问题如下：当一个对象实现时IEnumerable，JSON.net 将其标识为一个值数组并按照数组Json 语法（不包括属性）对其进行序列化，例如：

 [ {"FooProperty" : 123}, {"FooProperty" : 456}, {"FooProperty" : 789}]

如果要序列化它并保留属性，则需要通过定义自定义来手动处理该对象的序列化JsonConverter：

// intermediate class that can be serialized by JSON.net
// and contains the same data as FooCollection
class FooCollectionSurrogate
{
    // the collection of foo elements
    public List<Foo> Collection { get; set; }
    // the properties of FooCollection to serialize
    public string Bar { get; set; }
}

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

    public override object ReadJson(
        JsonReader reader, Type objectType, 
        object existingValue, JsonSerializer serializer)
    {
        // N.B. null handling is missing
        var surrogate = serializer.Deserialize<FooCollectionSurrogate>(reader);
        var fooElements = surrogate.Collection;
        var fooColl = new FooCollection { Bar = surrogate.Bar };
        foreach (var el in fooElements)
            fooColl.Add(el);
        return fooColl;
    }

    public override void WriteJson(JsonWriter writer, object value, 
                                   JsonSerializer serializer)
    {
        // N.B. null handling is missing
        var fooColl = (FooCollection)value;
        // create the surrogate and serialize it instead 
        // of the collection itself
        var surrogate = new FooCollectionSurrogate() 
        { 
            Collection = fooColl.ToList(), 
            Bar = fooColl.Bar 
        };
        serializer.Serialize(writer, surrogate);
    }
}

然后按如下方式使用它：

var ss = JsonConvert.SerializeObject(collection, new FooCollectionConverter());

var obj = JsonConvert.DeserializeObject<FooCollection>(ss, new FooCollectionConverter());
于 2013-01-17T17:34:26.117 回答
20

就我个人而言，我喜欢尽可能避免编写 custom JsonConverter，而是使用为此目的设计的各种 JSON 属性。您可以简单地用 装饰FooCollection，JsonObjectAttribute这会强制序列化为 JSON 对象而不是数组。您必须装饰CountandIsReadOnly属性JsonIgnore以防止它们出现在输出中。如果你想保留_foos一个私有字段，你还必须用JsonProperty.

[JsonObject]
class FooCollection : IList<Foo> {
    [JsonProperty]
    private List<Foo> _foos = new List<Foo>();
    public string Bar { get; set; }  

    // IList implementation
    [JsonIgnore]
    public int Count { ... }
    [JsonIgnore]
    public bool IsReadOnly { ... }
}

序列化产生如下内容：

{
  "_foos": [
    "foo1",
    "foo2"
  ],
  "Bar": "bar"
}

显然，这仅在您能够更改定义FooCollection以添加这些属性时才有效，否则您必须采用自定义转换器的方式。

于 2016-08-26T19:43:00.410 回答
3

如果您不想编写自定义JsonConverter或使用 JSON 属性 ( JsonObjectAttribute )，您可以使用以下扩展方法：

public static string ToFooJson<T>(this FooCollection fooCollection)
{
     return JsonConvert.SerializeObject(new
     {
         Bar = fooCollection.Bar,
         Collection = fooCollection
     });
}
于 2019-09-09T23:02:45.173 回答
3

如果您还想保留列表或集合本身的内容，您应该考虑公开一个属性以返回列表。它必须被包装以防止序列化时出现循环问题：

注意：此解决方案同时支持序列化/反序列化。

[JsonObject]
public class FooCollection : List<int>
{
    public string Bar { get; set; } = "Bar";

    [JsonProperty]
    ICollection<int> Items => new _<int>(this);
}

internal class _<T> : ICollection<T>
{
    public _(ICollection<T> collection) => inner = collection;
    private ICollection<T> inner;
    int ICollection<T>.Count => inner.Count;
    bool ICollection<T>.IsReadOnly => inner.IsReadOnly;
    void ICollection<T>.Add(T item) => inner.Add(item);
    void ICollection<T>.Clear() => inner.Clear();
    bool ICollection<T>.Contains(T item) => inner.Contains(item);
    void ICollection<T>.CopyTo(T[] array, int arrayIndex) => inner.CopyTo(array, arrayIndex);
    IEnumerator<T> IEnumerable<T>.GetEnumerator() => inner.GetEnumerator();
    bool ICollection<T>.Remove(T item) => inner.Remove(item);
    IEnumerator IEnumerable.GetEnumerator() => inner.GetEnumerator();
}

new FooCollection { 1, 2, 3, 4, 4 }=>

{
  "bar": "Bar",
  "items": [
    1,
    2,
    3
  ],
  "capacity": 4,
  "count": 3
}

new FooCollection { 1, 2, 3 }.ToArray()=>new []{1, 2, 3}.ToArray()

于 2017-08-19T14:50:53.783 回答
1

从 List 继承有效吗？

class FooCollection : List<Foo>, IList<Foo>
{
    public string Bar { get; set; }        
    //Implement IList, ICollection and IEnumerable members...
}
于 2013-01-17T16:38:45.297 回答
0

我最近正在测试类似的东西，并提出了以下示例（与@Ahmed Alejo 的答案非常相似，但不需要公共属性），它不需要自定义序列化程序：

void Main()
{
    var test = new Container();
    test.Children.Add("Item 1");
    test.Children.Add("Item 2");
    test.Children.Add("Item 3");
    
    Console.WriteLine(JsonConvert.SerializeObject(test));
}

class Container {
    public CustomList Children { get; set; } = new CustomList() { Name = Guid.NewGuid().ToString() };
}

[JsonObject(MemberSerialization = MemberSerialization.Fields)]
class CustomList : IList<string>
{
    private List<string> items = new List<string>();
    private string name;

    public string this[int index] { get => items[index]; set => items[index] = value; }

    public string Name { get => name; set { name = value; } }

    public int Count => items.Count;

    public bool IsReadOnly => false;

    public void Add(string item)
    {
        items.Add(item);
    }

    public void Clear()
    {
        items.Clear();
    }

    public bool Contains(string item) => items.Contains(item);

    public void CopyTo(string[] array, int arrayIndex)
    {
        items.CopyTo(array, arrayIndex);
    }

    public IEnumerator<string> GetEnumerator() => items.GetEnumerator();

    public int IndexOf(string item) => items.IndexOf(item);

    public void Insert(int index, string item)
    {
        items.Insert(index, item);
    }

    public bool Remove(string item) => items.Remove(item);

    public void RemoveAt(int index)
    {
        items.RemoveAt(index);
    }

    IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)items).GetEnumerator();
}

关键在于将显式添加JsonObjectAttribute到类中，这会将其视为对象而不是数组（也可以使用 显式表示JsonArrayAttribute）。上述测试的（美化）输出如下：

{
  "Children": {
    "items": [
      "Item 1",
      "Item 2",
      "Item 3"
    ],
    "name": "ff8768f7-5efb-4622-b7e2-f1472e80991c"
  }
}
于 2021-01-27T18:19:51.310 回答