JsonSerializer.CreateDefault().Populate(..) resets my values

问题

I have following class:

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";
    }
}

which I save as follows:

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"
        }
      ]
    }
  ]
}

then I deserialize and populate my object like this:

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]);
        }
    }
}

however, when I print following variables:

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);

then output of it is:

default value
value from json
default value
value from json

but instead of "default value" there should be "my value" because that is what I used while creating an instance of class and JsonSerializer should only populate the object with values from json.

How do I properly populate the whole object without resetting its properties which are not included in json?

回答1:

It looks as though JsonSerializer.Populate() lacks the MergeArrayHandling setting that is available for JObject.Merge(). Through testing I have found that:

Populating members that are arrays or some other type of read-only collection seems to work like MergeArrayHandling.Replace.

This is the behavior you are experiencing -- the existing array and all the items therein are being discarded and replaced with a fresh array containing newly constructed items that have default values. In contrast, you require MergeArrayHandling.Merge: Merge array items together, matched by index.
Populating members that are read/write collections such as List<T> seems to work like MergeArrayHandling.Concat.

It seems reasonable to request an enhancement that Populate() support this setting -- though I don't know how easy it would be to implement. At the minimum the documentation for Populate() should explain this behavior.

In the meantime, here's a custom JsonConverter with the necessary logic to emulate the behavior of 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();
    }
}

Then add the converter to your subClass member as follows:

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

Or, if you don't want to add Json.NET attributes to your data model, you can add it in serializer settings:

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

The converter is specifically designed for arrays but a similar converter could easily be created for read/write collections such as List<T>.

来源：https://stackoverflow.com/questions/40422136/jsonserializer-createdefault-populate-resets-my-values

标签

json

json.net

populate