Question

我有以下课程：

public class MainClass
{
    public static MainClass[] array = new MainClass[1]
    {
        new MainClass
        {
            subClass = new SubClass[2]
            {
                new SubClass
                {
                    variable1 = "my value"
                },
                new SubClass
                {
                    variable1 = "my value"
                }
            }
        }
    };

    public SubClass[] subClass;
    [DataContract]
    public  class SubClass
    {
        public string variable1 = "default value";
        [DataMember] // because only variable2 should be saved in json
        public string variable2 = "default value";
    }
}

我保存如下：

File.WriteAllText("data.txt", JsonConvert.SerializeObject(new
{
    MainClass.array
}, new JsonSerializerSettings { Formatting = Formatting.Indented }));

data.txt中：

{
  "array": [
    {
      "subClass": [
        {
          "variable2": "value from json"
        },
        {
          "variable2": "value from json"
        }
      ]
    }
  ]
}

然后我反序列化并填充我的对象：

JObject json = JObject.Parse(File.ReadAllText("data.txt"));
if (json["array"] != null)
{
    for (int i = 0, len = json["array"].Count(); i < len; i++)
    {
        using (var sr = json["array"][i].CreateReader())
        {
            JsonSerializer.CreateDefault().Populate(sr, MainClass.array[i]);
        }
    }
}

然而，当我打印以下变量时：

Console.WriteLine(MainClass.array[0].subClass[0].variable1);
Console.WriteLine(MainClass.array[0].subClass[0].variable2);
Console.WriteLine(MainClass.array[0].subClass[1].variable1);
Console.WriteLine(MainClass.array[0].subClass[1].variable2);

然后输出它是：

default value
value from json
default value
value from json

但不是“默认值”应该是“我的值”，因为这是我在创建类实例时使用的，而JsonSerializer应该只使用json中的值填充对象。

如何在不重置json中未包含的属性的情况下正确填充整个对象？

Answer 1

好像JsonSerializer.Populate()缺少MergeArrayHandling可用的JObject.Merge()设置。通过测试，我发现：

填充数组或其他类型的只读集合的成员似乎像MergeArrayHandling.Replace一样工作。

这是您遇到的行为 - 现有数组及其中的所有项目都将被丢弃，并替换为包含具有默认值的新构造项目的新数组。相反，您需要MergeArrayHandling.Merge：将数组项合并在一起，并与索引匹配。
填充像List<T>这样的读/写集合的成员似乎就像MergeArrayHandling.Concat一样。

request an enhancement Populate()支持此设置似乎是合理的 - 尽管我不知道实施起来有多容易。 Populate()的文档至少应该解释这种行为。

与此同时，这是一个自定义JsonConverter，其中包含模仿MergeArrayHandling.Merge行为的必要逻辑：

public class ArrayMergeConverter<T> : ArrayMergeConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType.IsArray && objectType.GetArrayRank() == 1 && objectType.GetElementType() == typeof(T);
    }
}

public class ArrayMergeConverter : JsonConverter
{
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (!objectType.IsArray)
            throw new JsonSerializationException(string.Format("Non-array type {0} not supported.", objectType));
        var contract = (JsonArrayContract)serializer.ContractResolver.ResolveContract(objectType);
        if (contract.IsMultidimensionalArray)
            throw new JsonSerializationException("Multidimensional arrays not supported.");
        if (reader.TokenType == JsonToken.Null)
            return null;
        if (reader.TokenType != JsonToken.StartArray)
            throw new JsonSerializationException(string.Format("Invalid start token: {0}", reader.TokenType));
        var itemType = contract.CollectionItemType;
        var existingList = existingValue as IList;
        IList list = new List<object>();
        while (reader.Read())
        {
            switch (reader.TokenType)
            {
                case JsonToken.Comment:
                    break;
                case JsonToken.Null:
                    list.Add(null);
                    break;
                case JsonToken.EndArray:
                    var array = Array.CreateInstance(itemType, list.Count);
                    list.CopyTo(array, 0);
                    return array;
                default:
                    // Add item to list
                    var existingItem = existingList != null && list.Count < existingList.Count ? existingList[list.Count] : null;
                    if (existingItem == null)
                    {
                        existingItem = serializer.Deserialize(reader, itemType);
                    }
                    else
                    {
                        serializer.Populate(reader, existingItem);
                    }
                    list.Add(existingItem);
                    break;
            }
        }
        // Should not come here.
        throw new JsonSerializationException("Unclosed array at path: " + reader.Path);
    }

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

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

    public override bool CanConvert(Type objectType)
    {
        throw new NotImplementedException();
    }
}

然后将转换器添加到subClass成员，如下所示：

    [JsonConverter(typeof(ArrayMergeConverter))]
    public SubClass[] subClass;

或者，如果您不想将Json.NET属性添加到数据模型中，可以将其添加到序列化程序设置中：

    var settings = new JsonSerializerSettings
    {
        Converters = new[] { new ArrayMergeConverter<MainClass.SubClass>() },
    };
    JsonSerializer.CreateDefault(settings).Populate(sr, MainClass.array[i]);

转换器专为阵列而设计，但可以轻松地为读/写集合创建类似的转换器，例如List<T>。

JsonSerializer.CreateDefault（）。Populate（..）重置我的值

1 个答案: