Serializing A Decimal To Json, How To Round Off?

I have a class public class Money { public string Currency { get; set; } public decimal Amount { get; set; } } and would like to serialize it to JSON. If I use the JavaSc

Solution 1:

I wasn't completely satisfied with all of the techniques thus far to achieve this. JsonConverterAttribute seemed the most promising, but I couldn't live with hard-coded parameters and proliferation of converter classes for every combination of options.

So, I submitted a PR that adds the ability to pass various arguments to JsonConverter and JsonProperty. It's been accepted upstream and I expect will be in the next release (whatever's next after 6.0.5)

You can then do it like this:

publicclassMeasurements
{
    [JsonProperty(ItemConverterType = typeof(RoundingJsonConverter))]
    public List<double> Positions { get; set; }

    [JsonProperty(ItemConverterType = typeof(RoundingJsonConverter), ItemConverterParameters = new object[] { 0, MidpointRounding.ToEven })]
    public List<double> Loads { get; set; }

    [JsonConverter(typeof(RoundingJsonConverter), 4)]
    publicdouble Gain { get; set; }
}

Refer to the CustomDoubleRounding() test for an example.

Solution 2:

For future reference, this can be achieved in Json.net pretty elegantly by creating a custom JsonConverter

publicclassDecimalFormatJsonConverter : JsonConverter
{
    privatereadonlyint _numberOfDecimals;

    publicDecimalFormatJsonConverter(int numberOfDecimals)
    {
        _numberOfDecimals = numberOfDecimals;
    }

    publicoverridevoidWriteJson(JsonWriter writer, objectvalue, JsonSerializer serializer)
    {
        var d = (decimal) value;
        var rounded = Math.Round(d, _numberOfDecimals);
        writer.WriteValue((decimal)rounded);
    }

    publicoverrideobjectReadJson(JsonReader reader, Type objectType, object existingValue,
        JsonSerializer serializer)
    {
        thrownew NotImplementedException("Unnecessary because CanRead is false. The type will skip the converter.");
    }

    publicoverridebool CanRead
    {
        get { returnfalse; }
    }

    publicoverrideboolCanConvert(Type objectType)
    {
        return objectType == typeof(decimal);
    }
}

If you're creating serializers in code using constructor explicitly, this will work fine but I think it's nicer to decorate the relevant properties with JsonConverterAttribute, in which case the class must have a public, parameterless constructor. I solved this by creating a subclass which is specific to the format I want.

publicclassSomePropertyDecimalFormatConverter : DecimalFormatJsonConverter
{
    publicSomePropertyDecimalFormatConverter() : base(3)
    {
    }
}

publicclassPoco 
{
    [JsonConverter(typeof(SomePropertyDecimalFormatConverter))]
    publicdecimal SomeProperty { get;set; }
}

The custom converter has been derived from Json.NET documentation.

Solution 3:

I just went through the same trouble as I had some decimals being serialized with 1.00 and some with 1.0000. This is my change:

Create a JsonTextWriter that can round the value to 4 decimals. Every decimal will then be rounded to 4 decimals: 1.0 becomes 1.0000 and 1.0000000 becomes also 1.0000

privateclassJsonTextWriterOptimized : JsonTextWriter
{
    publicJsonTextWriterOptimized(TextWriter textWriter)
        : base(textWriter)
    {
    }
    publicoverridevoidWriteValue(decimalvalue)
    {
        // we really really really want the value to be serialized as "0.0000" not "0.00" or "0.0000"!value = Math.Round(value, 4);
        // divide first to force the appearance of 4 decimalsvalue = Math.Round((((value+0.00001M)/10000)*10000)-0.00001M, 4); 
        base.WriteValue(value);
    }
}

Use your own writer instead of the standard one:

var jsonSerializer = Newtonsoft.Json.JsonSerializer.Create();
var sb = new StringBuilder(256);
var sw = new StringWriter(sb, CultureInfo.InvariantCulture);
using (var jsonWriter = new JsonTextWriterOptimized(sw))
{
    jsonWriter.Formatting = Formatting.None;
    jsonSerializer.Serialize(jsonWriter, instance);
}

Solution 4:

In the first case the 000 does no harm, the value still is the same and will be deserialized to the exact same value.

In the second case the JavascriptSerializer will not help you. The JavacriptSerializer is not supposed to change the data, since it serializes it to a well-known format it does not provide data conversion at member level (but it provides custom Object converters). What you want is a conversion + serialization, this is a two-phases task.

Two suggestions:

1) Use DataContractJsonSerializer: add another property that rounds the value:

publicclassMoney
{
    publicstring Currency { get; set; }

    [IgnoreDataMember]
    publicdecimal Amount { get; set; }

    [DataMember(Name = "Amount")]
    publicdecimal RoundedAmount { get{ return Math.Round(Amount, 2); } }
}

2) Clone the object rounding the values:

publicclassMoney 
{
    publicstring Currency { get; set; }

    publicdecimal Amount { get; set; }

    public Money CloneRounding() {
       var obj = (Money)this.MemberwiseClone();
       obj.Amount = Math.Round(obj.Amount, 2);
       return obj;
    }
}

var roundMoney = money.CloneRounding();

I guess json.net cannot do this either, but I'm not 100% sure.