Why long types are rounded in .NET Web API JSON response payload after 16 digits?

Question

I am working with web api 2 which I coincidentally realized that it rounds the long type value in the response model if it is longer than 16 digits.

(simplifying the example for the sake of the question) Assume I have a web api method as "GetOrders" which returns list of orderVm model which is defined as below:

public class OrderVm{
    public int OrderID {get;set;}
    public long? OrderNumber {get;set;}
}

What is happening is, if my order number value is

• 1234567890123459 there is no issue - total of 16 digits.
• 1234567890123499 there is no issue - total of 16 digits.
• 12345678901234599 this is the problematic one. total of 17 digits. It is rounding this to 12345678901234600

Below is my simplified example API Method:

        [HttpPost]
        [Route("get-orders/")]
        public IHttpActionResult GetOrders(PostedVm postedVm)
        {
              var orderDtoList = _orderManager.GetOrders(postedVm.Active); // I checked the value in orderDtoList and it is not rounded at this moment...
              var orderVmList  = MapDtoToVm(orderDtoList);    
              return Ok(orderVmList);// I thought maybe something happens during the property mapping (which is just using simple reflection) but I checked the value in orderVmList and it is not rounded at this moment...
        }

Even though right before returning the response, I checked that the values actually were not rounded.. But somehow on the client, it is coming as rounded. I thought maybe the browser does some magic (for some reason) but I checked my payload on postman and fiddler, it was showing that the value as rounded in the response payload.

This sounds something related to web api configuration but if so, how I can set it to not modify the data? And I am also curious about "why it is happening after 16 digits?"

Just in case I added my WebApiConfig class below:

 public static class WebApiConfig {
    public static void Register(HttpConfiguration config) {
        //GZip Compression
        GlobalConfiguration.Configuration.MessageHandlers.Insert(0, new ServerCompressionHandler(new GZipCompressor(), new DeflateCompressor()));

        // Web API routes
        config.MapHttpAttributeRoutes();
        config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));

        config.Routes.MapHttpRoute(
        name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new {
            id = RouteParameter.Optional
        });
    }
}

Answer 1

Thanks to Guy Incognito that he pointed me to the raw response of the JSON. In the raw response my values were not rounded. But when I parse the JSON the number was being too large for JavaScript and as floating point numbers don't have infinite precision, I was having this issue. I ended up changing my data type to string as I don't do any arithmetic operations with that anyways.

Thanks to Guy Incognito again, this SO post was also very helpful.

Answer 2

This is most likey due to number represented as IEEE 754 (double in C#).

Due to the binary representation rounding may apply, so that 12345678901234599 and 12345678901234600 have the same binary representation.

You can observe this behavior in C# as well:

double x = 12345678901234599;
double y = 12345678901234600;
Console.WriteLine(x == y); // Prints true

https://dotnetfiddle.net/G0KOqZ

EDIT: Despite my original answer the JSON standard does not specify numeric limits, but the problem is the same.

This specification allows implementations to set limits on the range and precision of numbers accepted. Since software that implements IEEE 754 binary64 (double precision) numbers [IEEE754] is generally available and widely used, good interoperability can be achieved by implementations that expect no more precision or range than these provide, in the sense that implementations will approximate JSON numbers within the expected precision.

https://www.rfc-editor.org/rfc/rfc8259#section-6