Serializing dziesiętny na JSON, jak zaokrąglić?

Question

Mam klasy

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

i chciałbyś go do serializacji JSON. Jeśli używam JavaScriptSerializer uzyskać

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

Ponieważ API muszę odpowiadać na potrzeby JSON ilościach z maksymalnie dwóch miejsc po przecinku, czuję powinno być możliwe, aby w jakiś sposób zmieniają sposób, w jaki JavaScriptSerializer serializes pole dziesiętny, ale nie mogę się dowiedzieć jak. Istnieje SimpleTypeResolver, który możesz przekazać w konstruktorze, ale działa tylko na typach, o ile mogę to zrozumieć. Numer JavaScriptConverter, który można dodać za pomocą RegisterConverters (...), wydaje się być wykonany dla Dictionary.

Chciałbym dostać

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

po I serializacji. Również przejście do podwójnego nie wchodzi w rachubę. I prawdopodobnie potrzebuję trochę zaokrąglić (100.311 powinno stać się 100.31).

Czy ktoś wie, jak to zrobić? Czy istnieje alternatywa dla JavaScriptSerializer, która pozwala bardziej szczegółowo sterować serializacją?

Answer 1

W pierwszym przypadku 000 nie robi szkody, wartość nadal jest taka sama i będzie deserializowana do dokładnie tej samej wartości.

W drugim przypadku JavascriptSerializer nie pomoże. JavacriptSerializer nie powinien zmieniać danych, ponieważ przekształca je do znanego formatu, który nie zapewnia konwersji danych na poziomie użytkownika (ale zapewnia niestandardowe konwertery obiektów). To, czego chcesz, to serializacja konwersji + to zadanie dwufazowe.

dwie propozycje:

1) Za pomocą DataContractJsonSerializer: dodać kolejną właściwość, która zaokrągla wartość:

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) klon obiektu zaokrąglania wartości:

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

Chyba json.net nie mogę tego zrobić, ale nie jestem w 100% pewny.

Answer 2

Po prostu przeszedłem przez ten sam problem, ponieważ miałem kilka cyfr po przecinku z serią 1,00, a niektóre z 1,0000. To jest moja zmiana:

Utwórz JsonTextWriter, który może zaokrąglić wartość do 4 miejsc dziesiętnych. Każdy dziesiętny zostanie zaokrąglona do 4 miejsc po przecinku: 1.0 staje 1,0000 i 1,0000000 również staje 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); 
    } 
} 

Użyj własnego pisarz zamiast standardowego jednego:

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

Na przyszłość, można to osiągnąć w Json.netto dość elegancko, tworząc zwyczaj 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); 
    } 
} 

Jeśli tworzysz serializers w kodzie za pomocą konstruktora jawnie, to będzie działać dobrze, ale myślę, że jest ładniejszy ozdobić odpowiednie właściwości z JsonConverterAttribute, w którym to przypadku klasy muszą mieć publiczny konstruktor bez parametrów. Rozwiązałem to, tworząc podklas, która jest specyficzna dla formatu, który chcę.

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

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

Konwerter niestandardowy pochodzi z Json.NET documentation.

Answer 4

Nie byłem w pełni usatysfakcjonowany wszystkimi dotychczasowymi technikami, aby to osiągnąć. JsonConverterAttribute wydawał się najbardziej obiecujący, ale nie mogłem żyć z mocno zakodowanymi parametrami i proliferacją klas konwerterów dla każdej kombinacji opcji.

Tak, przesłałem PR, który dodaje możliwość przekazywania różnych argumentów do JsonConverter i JsonProperty. To zostało przyjęte w górę i spodziewam się będzie w następnej wersji (co jest następny po 6.0.5)

Następnie można zrobić to tak:

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

Patrz testu CustomDoubleRounding() dla przykładu.