Serializzare un decimale in JSON, come arrotondare?

Question

Ho una classe

public class Money 
{ 
    public string Currency { get; set; } 
    public decimal Amount { get; set; } 
} 

e vorrebbe serializzare a JSON. Se uso il JavaScriptSerializer ottengo

{"Currency":"USD","Amount":100.31000} 

A causa della API devo conformarsi alle esigenze JSON ammonta con un massimo di due cifre decimali, ritengo che dovrebbe essere possibile modificare in qualche modo il modo in cui il JavaScriptSerializer serializza un campo decimale, ma non riesco a scoprire come. C'è lo SimpleTypeResolver che puoi passare nel costruttore, ma funziona solo sui tipi per quanto posso capire. È possibile creare JavaScriptConverter, che è possibile aggiungere tramite RegisterConverters (...) per Dictionary.

vorrei ottenere

{"Currency":"USD","Amount":100.31} 

dopo ho serializzare. Inoltre, il passaggio al doppio è fuori questione. E probabilmente ho bisogno di fare qualche arrotondamento (100.311 dovrebbe diventare 100.31).

Qualcuno sa come fare? C'è forse un'alternativa allo JavaScriptSerializer che ti permette di controllare la serializzazione in modo più dettagliato?

Answer 1

Nel primo caso il 000 non danneggia, il valore è lo stesso e verrà deserializzato allo stesso valore.

Nel secondo caso JavascriptSerializer non ti aiuterà. Lo JavacriptSerializer non deve modificare i dati, poiché lo serializza in un formato noto non fornisce la conversione dei dati a livello di membro (ma fornisce convertitori oggetto personalizzati). Quello che vuoi è una conversione + serializzazione, questo è un compito a due fasi.

due suggerimenti:

1) Utilizzare DataContractJsonSerializer: aggiungere un'altra proprietà che arrotonda il valore:

public class Money 
{ 
    public string Currency { get; set; } 

    [IgnoreDataMember] 
    public decimal Amount { get; set; } 

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

2) Clonare l'oggetto di arrotondamento dei valori:

public class Money 
{ 
    public string Currency { get; set; } 

    public decimal Amount { get; set; } 

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

var roundMoney = money.CloneRounding(); 

immagino json.net non posso farlo neanche io, ma non ne sono sicuro al 100%.

Answer 2

Ho appena avuto lo stesso problema dato che alcuni decimali sono stati serializzati con 1.00 e alcuni con 1.0000. Questa è la mia modifica:

Creare un JsonTextWriter che può arrotondare il valore a 4 decimali. Ogni decimale sarà poi arrotondato a 4 decimali: 1.0 diventa 1.0000 e 1,0 milioni diventa anche 1,0000

private class JsonTextWriterOptimized : JsonTextWriter 
{ 
    public JsonTextWriterOptimized(TextWriter textWriter) 
     : base(textWriter) 
    { 
    } 
    public override void WriteValue(decimal value) 
    { 
     // 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 decimals 
     value = Math.Round((((value+0.00001M)/10000)*10000)-0.00001M, 4); 
     base.WriteValue(value); 
    } 
} 

Utilizzare il proprio scrittore, invece di quella standard:

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

Answer 3

Per riferimento futuro, questo può essere realizzato in Json.net abbastanza elegantemente con la creazione di un custom JsonConverter

public class DecimalFormatJsonConverter : JsonConverter 
{ 
    private readonly int _numberOfDecimals; 

    public DecimalFormatJsonConverter(int numberOfDecimals) 
    { 
     _numberOfDecimals = numberOfDecimals; 
    } 

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) 
    { 
     var d = (decimal) value; 
     var rounded = Math.Round(d, _numberOfDecimals); 
     writer.WriteValue((decimal)rounded); 
    } 

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

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

    public override bool CanConvert(Type objectType) 
    { 
     return objectType == typeof(decimal); 
    } 
} 

Se si sta creando serializzatori nel codice utilizzando il costruttore in modo esplicito, questo funzionerà bene, ma penso che sia più bello per decorare le proprietà rilevanti con JsonConverterAttribute, nel qual caso la classe deve avere un costruttore pubblico, senza parametri. Ho risolto questo creando una sottoclasse che è specifica per il formato che voglio.

public class SomePropertyDecimalFormatConverter : DecimalFormatJsonConverter 
{ 
    public SomePropertyDecimalFormatConverter() : base(3) 
    { 
    } 
} 

public class Poco 
{ 
    [JsonConverter(typeof(SomePropertyDecimalFormatConverter))] 
    public decimal SomeProperty { get;set; } 
} 

Il convertitore personalizzato è stato derivato da Json.NET documentation.

Answer 4

Non ero completamente soddisfatto di tutte le tecniche finora necessarie per raggiungere questo obiettivo. JsonConverterAttribute sembrava il più promettente, ma non potevo vivere con parametri hard-coded e proliferazione di classi di convertitori per ogni combinazione di opzioni.

Quindi, ho inviato uno PR che aggiunge la possibilità di passare vari argomenti a JsonConverter e JsonProperty. E 'stato accettato a monte e mi aspetto che sarà nella prossima release (qualunque sia il prossimo dopo la 6.0.5)

È quindi possibile fare in questo modo:

public class Measurements 
{ 
    [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)] 
    public double Gain { get; set; } 
} 

Fare riferimento alla prova CustomDoubleRounding() per un esempio.