Have Geek Brain

How to apply ObjectCreationHandling.Replace to selected properties when deserializing JSON?

I have a class that contains a property List<Tuple<int, int, int>>

whose default constructor distributes the list and populates it with some default values, for example:

public class Configuration
{
    public List<Tuple<int, int, int>> MyThreeTuple { get; set; }

    public Configuration()
    {
        MyThreeTuple = new List<Tuple<int, int, int>>();
        MyThreeTuple.Add(new Tuple<int, int, int>(-100, 20, 501));
        MyThreeTuple.Add(new Tuple<int, int, int>(100, 20, 864));
        MyThreeTuple.Add(new Tuple<int, int, int>(500, 20, 1286));
    }
}

When I deserialize an instance of this class from JSON using Json.NET, the values ​​from the JSON are added to the list rather than replaced by the items in the list, resulting in the list having too many values. The solution to this problem is given in Json.Net calls the getter property while deserializing the list, which results in duplicate elements .

var settings = new JsonSerializerSettings { ObjectCreationHandling = ObjectCreationHandling.Replace };
var config = JsonConvert.DeserializeObject<Configuration>(jsonString, settings);

This causes Json.NET to allocate fresh instances, all deserialized.

However, this creates an additional problem: my class exists in a larger object graph, and some types in the graph do not have default constructors. Instead, they are created by the constructor in the containing class. If I use ObjectCreationHandling = ObjectCreationHandling.Replace

Json.NET does not try to instantiate these types with the following exception:

Unable to find a constructor to use for the type MySpecialType. A class 
should either have a default constructor, one constructor with arguments
or a constructor marked with the JsonConstructor attribute.

How can I apply ObjectCreationHandling.Replace

selectively to certain properties in my object graph and not others?

+3
json c # serialization json.net


source to share


1 answer


You have several alternatives to force-replace the list rather than reuse it:



  • You can add an attribute to the list property indicating that it should not be replaced again:

    public class Configuration
{
    [JsonProperty(ObjectCreationHandling = ObjectCreationHandling.Replace)]
    public List<Tuple<int, int, int>> MyThreeTuple { get; set; }
}

  • You can use an array instead of a list, as arrays are always replaced. This might make sense if your list should always contain three elements and never change:

    public class Configuration
{
    public Tuple<int, int, int>[] MyThreeTuple { get; set; }

    public Configuration()
    {
        MyThreeTuple = new[]
        {
            new Tuple<int, int, int>(-100, 20, 501),
            new Tuple<int, int, int>(100, 20, 864),
            new Tuple<int, int, int>(500, 20, 1286),
        };
    }
}

  • If you don't want your class definitions to depend on Json.NET, you can create a custom JsonConverter

    one that clears the list on deserialization:

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

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var config = (existingValue as Configuration ?? (Configuration)serializer.ContractResolver.ResolveContract(objectType).DefaultCreator());
        if (config.MyThreeTuple != null)
            config.MyThreeTuple.Clear();
        serializer.Populate(reader, config);
        return config;
    }

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

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

    Then use it with the following JsonSerializerSettings

    :

    var settings = new JsonSerializerSettings { Converters = new JsonConverter[] { new ConfigurationConverter() } };

  • If you want all properties of the list to be replaced rather than reused, you can create a custom ContractResolver

    one that does the following:

    public class ListReplacementContractResolver : DefaultContractResolver
{
    // As of 7.0.1, Json.NET suggests using a static instance for "stateless" contract resolvers, for performance reasons.
    // http://www.newtonsoft.com/json/help/html/ContractResolver.htm
    // http://www.newtonsoft.com/json/help/html/M_Newtonsoft_Json_Serialization_DefaultContractResolver__ctor_1.htm
    // "Use the parameterless constructor and cache instances of the contract resolver within your application for optimal performance."
    static readonly ListReplacementContractResolver instance;

    // Using a static constructor enables fairly lazy initialization.  http://csharpindepth.com/Articles/General/Singleton.aspx
    static ListReplacementContractResolver() { instance = new ListReplacementContractResolver(); }

    public static ListReplacementContractResolver Instance { get { return instance; } }

    protected ListReplacementContractResolver() : base() { }

    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        var jsonProperty = base.CreateProperty(member, memberSerialization);
        if (jsonProperty.ObjectCreationHandling == null && jsonProperty.PropertyType.GetListType() != null)
            jsonProperty.ObjectCreationHandling = ObjectCreationHandling.Replace;
        return jsonProperty;
    }
}

public static class TypeExtensions
{
    public static Type GetListType(this Type type)
    {
        while (type != null)
        {
            if (type.IsGenericType)
            {
                var genType = type.GetGenericTypeDefinition();
                if (genType == typeof(List<>))
                    return type.GetGenericArguments()[0];
            }
            type = type.BaseType;
        }
        return null;
    }
}

    Then use it with the following settings:

    var settings = new JsonSerializerSettings { ContractResolver = ListReplacementContractResolver.Instance };

  • If the collection is get-only (which is not the case), see Clear Collections Before Adding Items While Populating Existing Objects .

+11


source to share






More articles:


All Articles