C# Newtonsoft.Json.Linq.JValue always returning Int64

Question

I am using the Newtonsoft.Json assembly to de-serialize a Json string into a dynamic object (ExpandoObject). The problem I am having is the int value is always returned as an Int64 where I am expecting an Int32. The code can be seen below.

namespace Serialization
{
    using System;
    using System.Collections.Generic;
    using System.Dynamic;
    using System.Linq;

    using Newtonsoft.Json;
    using Newtonsoft.Json.Linq;

    public static class JsonSerializer
    {
        #region Public Methods

        public static string Serialize(dynamic obj)
        {
            return JsonConvert.SerializeObject(obj);
        }

        public static dynamic Deserialize(string s)
        {
            var obj = JsonConvert.DeserializeObject(s);
            return obj is string ? obj as string : Deserialize((JToken)obj);
        }

        #endregion

        #region Methods

        private static dynamic Deserialize(JToken token)
        {
            // FROM : http://blog.petegoo.com/archive/2009/10/27/using-json.net-to-eval-json-into-a-dynamic-variable-in.aspx
            // Ideally in the future Json.Net will support dynamic and this can be eliminated.
            if (token is JValue) return ((JValue)token).Value;
            if (token is JObject)
            {
                var expando = new ExpandoObject();
                (from childToken in token
                 where childToken is JProperty
                 select childToken as JProperty).ToList().
                    ForEach(property => ((IDictionary<string, object>)expando).Add(property.Name, Deserialize(property.Value)));
                return expando;
            }
            if (token is JArray)
            {
                var items = new List<object>();
                foreach (var arrayItem in ((JArray)token)) items.Add(Deserialize(arrayItem));
                return items;
            }
            throw new ArgumentException(string.Format("Unknown token type '{0}'", token.GetType()), "token");
        }

        #endregion
    }
}

Normally I wouldn't notice this but this particular int is being used in reflection for some type checking and it fails miserably. Any ideas why this is happening would be greatly appreciated.

Fixed by using jsonfx instead! https://github.com/jsonfx/jsonfx/downloads — Tri Q Tran, Nov 23 '11 at 05:53
I agree with you. There should be an option to deserialize to Int32. Or a way to embed the type for Int32. This is currently causing me aggravation. — Kasey Speakman, Jan 23 '14 at 22:39
No, for lack of time I ended up using BinaryMessageFormatter instead. — Kasey Speakman, Jan 30 '14 at 16:20

score 6 · Accepted Answer · edited Apr 26 '19 at 10:57

Cross-linking to answer https://stackoverflow.com/a/9444519/1037948

From How do I change the default Type for Numeric deserialization?

Paraphrased:

The author intentionally chose that all int's come back as Int64 to avoid overflow errors, and it's easier to check (for Json.NET internals, not you)
You can get around this with a custom converter like the one posted in the linked answer.

Here's a really generic converter; not entirely sure about the CanConvert check, but the important part that worked for me was allowing typeof(object):

/// <summary>
/// To address issues with automatic Int64 deserialization -- see https://stackoverflow.com/a/9444519/1037948
/// </summary>
public class JsonInt32Converter : JsonConverter
{
    #region Overrides of JsonConverter

    /// <summary>
    /// Only want to deserialize
    /// </summary>
    public override bool CanWrite { get { return false; } }

    /// <summary>
    /// Placeholder for inheritance -- not called because <see cref="CanWrite"/> returns false
    /// </summary>
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        // since CanWrite returns false, we don't need to implement this
        throw new NotImplementedException();
    }

    /// <summary>
    /// Reads the JSON representation of the object.
    /// </summary>
    /// <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read from.</param><param name="objectType">Type of the object.</param><param name="existingValue">The existing value of object being read.</param><param name="serializer">The calling serializer.</param>
    /// <returns>
    /// The object value.
    /// </returns>
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        return (reader.TokenType == JsonToken.Integer)
            ? Convert.ToInt32(reader.Value)     // convert to Int32 instead of Int64
            : serializer.Deserialize(reader);   // default to regular deserialization
    }

    /// <summary>
    /// Determines whether this instance can convert the specified object type.
    /// </summary>
    /// <param name="objectType">Type of the object.</param>
    /// <returns>
    /// <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
    /// </returns>
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(Int32) ||
                objectType == typeof(Int64) ||
                // need this last one in case we "weren't given" the type
                // and this will be accounted for by `ReadJson` checking tokentype
                objectType == typeof(object)
            ;
    }

    #endregion
}

This is also a good reference http://stackoverflow.com/questions/17745866/how-can-i-restore-the-int-deserialization-behavior-after-upgrading-json-net, specifically [this answer](http://stackoverflow.com/a/17749727/1037948) — drzaus, Feb 26 '15 at 18:06
Update: recently started seeing `NotImplementedException`s for `WriteJson`, not sure what's going on... — drzaus, Jun 30 '15 at 17:41

score 0 · Answer 2 · answered May 07 '15 at 05:34

I was having a somewhat similar problem, but went ahead and and answered your question - casting to Int32, if possible and then Int16, if possible. I included tests as well. For future readers, it'd make sense to do this for other value types as well, but I only implemented signed integers here.

namespace Serialization
{
    using System;
    using System.Collections.Generic;
    using System.Dynamic;
    using System.Linq;

    using Newtonsoft.Json;
    using Newtonsoft.Json.Linq;

    public static class JsonSerializer
    {
        #region Public Methods

        public static string Serialize(dynamic obj)
        {
            return JsonConvert.SerializeObject(obj);
        }

        public static dynamic Deserialize(string s)
        {
            var obj = JsonConvert.DeserializeObject(s);
            return obj is string ? obj as string : Deserialize((JToken)obj);
        }

        #endregion

        #region Methods

        private static dynamic Deserialize(JToken token)
        {
            // FROM : http://blog.petegoo.com/archive/2009/10/27/using-json.net-to-eval-json-into-a-dynamic-variable-in.aspx
            // Ideally in the future Json.Net will support dynamic and this can be eliminated.
            if (token is JValue)
            {
                var value = ((JValue)token).Value;
                if (value is Int64)
                {
                    var lValue = (Int64)value;
                    if (Int32.MinValue <= lValue && lValue <= 0 || 0 < lValue && lValue <= Int32.MaxValue)
                    {
                        var iValue = (Int32)lValue;
                        value = iValue;
                        // Take out this if you don't want to cast down to Int16.
                        if (Int16.MinValue <= iValue && iValue <= 0 || 0 < iValue && iValue <= Int16.MaxValue)
                        {
                            value = (Int16)iValue;
                        }
                    }
                }
                return value;
            }
            if (token is JObject)
            {
                var expando = new ExpandoObject();
                (from childToken in token
                 where childToken is JProperty
                 select childToken as JProperty).ToList().
                    ForEach(property => ((IDictionary<string, object>)expando).Add(property.Name, Deserialize(property.Value)));
                return expando;
            }
            if (token is JArray)
            {
                var items = new List<object>();
                foreach (var arrayItem in ((JArray)token)) items.Add(Deserialize(arrayItem));
                return items;
            }
            throw new ArgumentException(string.Format("Unknown token type '{0}'", token.GetType()), "token");
        }

        #endregion
    }
}

namespace Serialization.Tests
{
    public class JsonSerializerTests
    {
        [Test]
        public void ShouldDeserializeAsInt16([Values(0, Int16.MaxValue, Int16.MinValue)] Int16 x)
        {
            var json = string.Format("{{ x: {0} }}", x);
            var dynamic = JsonSerializer.Deserialize(json);

            Assert.That(dynamic.x.GetType(), Is.EqualTo(typeof(Int16)));
        }

        [Test]
        public void ShouldDeserializeAsInt32([Values(Int16.MaxValue + 1, Int16.MinValue - 1)] Int32 x)
        {
            var json = string.Format("{{ x: {0} }}", x);
            var dynamic = JsonSerializer.Deserialize(json);

            Assert.That(dynamic.x.GetType(), Is.EqualTo(typeof(Int32)));
        }

        [Test]
        public void ShouldDeserializeAsInt64([Values(Int32.MaxValue + 1L, Int32.MinValue - 1L)] Int64 x)
        {
            var json = string.Format("{{ x: {0} }}", x);
            var dynamic = JsonSerializer.Deserialize(json);

            Assert.That(dynamic.x.GetType(), Is.EqualTo(typeof(Int64)));
        }
    }
}

This seems to be very close to what I need, except it's old -- now JSON.Net will convert to ExpandoObject directly, but I want to have it convert any ints to Int32. Most of the "JsonInt32Converters" just convert arrays of numbers. Can you direct me somewhere to determine how to do this? — Michael Blackburn, Aug 29 '19 at 18:59
@MichaelBlackburn Is this what you want? https://dotnetfiddle.net/B4slQs — Jesus is Lord, Aug 30 '19 at 18:19
Yes, that's similar. I ended up just letting it convert to Int64. I had a lot of other logic and validation to perform, so I ended up putting a buffer-check and resize on all the int values there. Thanks! — Michael Blackburn, Sep 10 '19 at 18:38

C# Newtonsoft.Json.Linq.JValue always returning Int64

2 Answers2

Linked