serialize: Serialize constructed Value and Unit

angularsen · angularsen · commit bc3ee4d4cf99 · 2018-02-10T15:24:49.000+01:00
Serialize with constructed Unit and _value instead of base unit and base unit value.
Cast to QuantityValueDecimal for types that use decimal internally.

NOTE: This mix of double and decimal representations is a bit messy right
now and needs a better fix. We already discuss this topic about either moving everything to decimal
or to better support multiple numeric types (float, double, long,
decimal etc).
diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetJsonConverterTests.cs b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetJsonConverterTests.cs
@@ -51,24 +51,35 @@ public class Serialize : UnitsNetJsonConverterTests
             public void Information_CanSerializeVeryLargeValues()
             {
                 Information i = Information.FromExabytes(1E+9);
-                var expectedJson = "{\n  \"Unit\": \"InformationUnit.Bit\",\n  \"Value\": 8E+27\n}";
+                var expectedJson = "{\n  \"Unit\": \"InformationUnit.Exabyte\",\n  \"Value\": 1000000000.0\n}";
 
                 string json = SerializeObject(i);
 
                 Assert.Equal(expectedJson, json);
             }
 
             [Fact]
-            public void Mass_ExpectKilogramsUsedAsBaseValueAndUnit()
+            public void Mass_ExpectConstructedValueAndUnit()
             {
                 Mass mass = Mass.FromPounds(200);
-                var expectedJson = "{\n  \"Unit\": \"MassUnit.Kilogram\",\n  \"Value\": 90.718474\n}";
+                var expectedJson = "{\n  \"Unit\": \"MassUnit.Pound\",\n  \"Value\": 200.0\n}";
 
                 string json = SerializeObject(mass);
 
                 Assert.Equal(expectedJson, json);
             }
 
+            [Fact]
+            public void Information_ExpectConstructedValueAndUnit()
+            {
+                Information quantity = Information.FromKilobytes(54);
+                var expectedJson = "{\n  \"Unit\": \"InformationUnit.Kilobyte\",\n  \"Value\": 54.0\n}";
+
+                string json = SerializeObject(quantity);
+
+                Assert.Equal(expectedJson, json);
+            }
+
             [Fact]
             public void NonNullNullableValue_ExpectJsonUnaffected()
             {
@@ -122,7 +133,7 @@ public void NullValue_ExpectJsonContainsNullString()
             public void Ratio_ExpectDecimalFractionsUsedAsBaseValueAndUnit()
             {
                 Ratio ratio = Ratio.FromPartsPerThousand(250);
-                var expectedJson = "{\n  \"Unit\": \"RatioUnit.DecimalFraction\",\n  \"Value\": 0.25\n}";
+                var expectedJson = "{\n  \"Unit\": \"RatioUnit.PartPerThousand\",\n  \"Value\": 250.0\n}";
 
                 string json = SerializeObject(ratio);
 
@@ -376,4 +387,4 @@ private class TestObjWithThreeIComparable
             public IComparable Value3 { get; set; }
         }
     }
-}
+}
diff --git a/UnitsNet.Serialization.JsonNet/UnitsNetJsonConverter.cs b/UnitsNet.Serialization.JsonNet/UnitsNetJsonConverter.cs
@@ -20,7 +20,6 @@
 // THE SOFTWARE.
 
 using System;
-using System.Globalization;
 using System.Linq;
 using System.Reflection;
 using JetBrains.Annotations;
@@ -29,9 +28,10 @@
 
 namespace UnitsNet.Serialization.JsonNet
 {
+    /// <inheritdoc />
     /// <summary>
-    ///     A JSON.net <see cref="JsonConverter" /> for converting to/from JSON and Units.NET
-    ///     units like <see cref="Length" /> and <see cref="Mass" />.
+    ///     A JSON.net <see cref="T:Newtonsoft.Json.JsonConverter" /> for converting to/from JSON and Units.NET
+    ///     units like <see cref="T:UnitsNet.Length" /> and <see cref="T:UnitsNet.Mass" />.
     /// </summary>
     /// <remarks>
     ///     Relies on reflection and the type names and namespaces as of 3.x.x of Units.NET.
@@ -42,6 +42,11 @@ namespace UnitsNet.Serialization.JsonNet
     /// </remarks>
     public class UnitsNetJsonConverter : JsonConverter
     {
+        /// <summary>
+        /// Numeric value field of a quantity, typically of type double or decimal.
+        /// </summary>
+        private const string ValueFieldName = "_value";
+
         /// <summary>
         ///     Reads the JSON representation of the object.
         /// </summary>
@@ -61,9 +66,8 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
                 return reader.Value;
             }
             object obj = TryDeserializeIComparable(reader, serializer);
-            var vu = obj as ValueUnit;
             // A null System.Nullable value or a comparable type was deserialized so return this
-            if (vu == null)
+            if (!(obj is ValueUnit vu))
             {
                 return obj;
             }
@@ -73,13 +77,13 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
             string unitEnumValue = vu.Unit.Split('.')[1];
 
             // "MassUnit" => "Mass"
-            string unitTypeName = unitEnumTypeName.Substring(0, unitEnumTypeName.Length - "Unit".Length);
+            string quantityTypeName = unitEnumTypeName.Substring(0, unitEnumTypeName.Length - "Unit".Length);
 
             // "UnitsNet.Units.MassUnit,UnitsNet"
             string unitEnumTypeAssemblyQualifiedName = "UnitsNet.Units." + unitEnumTypeName + ",UnitsNet";
 
             // "UnitsNet.Mass,UnitsNet"
-            string unitTypeAssemblyQualifiedName = "UnitsNet." + unitTypeName + ",UnitsNet";
+            string quantityTypeAssemblyQualifiedName = "UnitsNet." + quantityTypeName + ",UnitsNet";
 
             // -- see http://stackoverflow.com/a/6465096/1256096 for details
             Type reflectedUnitEnumType = Type.GetType(unitEnumTypeAssemblyQualifiedName);
@@ -90,18 +94,18 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
                 throw ex;
             }
 
-            Type reflectedUnitType = Type.GetType(unitTypeAssemblyQualifiedName);
+            Type reflectedUnitType = Type.GetType(quantityTypeAssemblyQualifiedName);
             if (reflectedUnitType == null)
             {
                 var ex = new UnitsNetException("Unable to find unit type.");
-                ex.Data["type"] = unitTypeAssemblyQualifiedName;
+                ex.Data["type"] = quantityTypeAssemblyQualifiedName;
                 throw ex;
             }
 
-            object unit = Enum.Parse(reflectedUnitEnumType, unitEnumValue);
+            object unitValue = Enum.Parse(reflectedUnitEnumType, unitEnumValue);
 
             // Mass.From() method, assume no overloads exist
-            var fromMethod = reflectedUnitType
+            MethodInfo fromMethod = reflectedUnitType
 #if (NETSTANDARD1_0)
                     .GetTypeInfo()
                 .GetDeclaredMethods("From")
@@ -112,14 +116,40 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
                     !m.ReturnType.IsGenericType);
 #endif
 
-            // Implicit cast: we use this type to avoid explosion of method overloads to handle multiple number types
-            QuantityValue quantityValue = vu.Value;
+            // Either of type QuantityValue or QuantityValueDecimal
+            object quantityValue = GetFromMethodValueArgument(fromMethod, vu.Value);
 
             // Ex: Mass.From(55, MassUnit.Gram)
             // TODO: there is a possible loss of precision if base value requires higher precision than double can represent.
             // Example: Serializing Information.FromExabytes(100) then deserializing to Information 
             // will likely return a very different result. Not sure how we can handle this?
-            return fromMethod.Invoke(null, new[] {quantityValue, unit});
+            return fromMethod.Invoke(null, new[] {quantityValue, unitValue});
+        }
+
+        /// <summary>
+        /// Returns numeric value wrapped as <see cref="QuantityValue"/> or <see cref="QuantityValueDecimal"/>, depending
+        /// on what type the first parameter. Two examples are <see cref="Mass.From(UnitsNet.QuantityValue,UnitsNet.Units.MassUnit)"/> and
+        /// <see cref="Information.From(UnitsNet.QuantityValueDecimal,UnitsNet.Units.InformationUnit)"/>.
+        /// </summary>
+        /// <param name="fromMethod">The reflected From(value, unit) method.</param>
+        /// <param name="value">The value to convert to the correct wrapper type.</param>
+        /// <returns></returns>
+        private static object GetFromMethodValueArgument(MethodInfo fromMethod, double value)
+        {
+            Type valueParameterType = fromMethod.GetParameters()[0].ParameterType;
+            if (valueParameterType == typeof(QuantityValue))
+            {
+                // Implicit cast: we use this type to avoid explosion of method overloads to handle multiple number types
+                return (QuantityValue) value;
+            }
+
+            if (valueParameterType == typeof(QuantityValueDecimal))
+            {
+                return (QuantityValueDecimal) value;
+            }
+
+            throw new Exception(
+                $"The first parameter of the reflected quantity From() method was expected to be either UnitsNet.QuantityValue or UnitsNet.QuantityValueDecimal, but was instead {valueParameterType}.");
         }
 
         private static object TryDeserializeIComparable(JsonReader reader, JsonSerializer serializer)
@@ -147,77 +177,99 @@ private static object TryDeserializeIComparable(JsonReader reader, JsonSerialize
         ///     Writes the JSON representation of the object.
         /// </summary>
         /// <param name="writer">The <see cref="T:Newtonsoft.Json.JsonWriter" /> to write to.</param>
-        /// <param name="value">The value to write.</param>
+        /// <param name="obj">The value to write.</param>
         /// <param name="serializer">The calling serializer.</param>
         /// <exception cref="UnitsNetException">Can't serialize 'null' value.</exception>
-        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        public override void WriteJson(JsonWriter writer, object obj, JsonSerializer serializer)
         {
-            Type unitType = value.GetType();
+            Type quantityType = obj.GetType();
 
             // ValueUnit should be written as usual (but read in a custom way)
-            if(unitType == typeof(ValueUnit))
+            if(quantityType == typeof(ValueUnit))
             {
                 JsonSerializer localSerializer = new JsonSerializer()
                 {
                     TypeNameHandling = serializer.TypeNameHandling,
                 };
-                JToken t = JToken.FromObject(value, localSerializer);
+                JToken t = JToken.FromObject(obj, localSerializer);
                 
                 t.WriteTo(writer);
                 return;
             }
+
+            object quantityValue = GetValueOfQuantity(obj, quantityType); // double or decimal value
+            string quantityUnitName = GetQuantityUnitName(obj, quantityType); // Example: "MassUnit.Kilogram"
+
+            serializer.Serialize(writer, new ValueUnit
+            {
+                // This might throw OverflowException for very large values?
+                // TODO Should we serialize long, decimal and long differently?
+                Value = Convert.ToDouble(quantityValue),
+                Unit = quantityUnitName
+            });
+        }
+
+        private static string GetQuantityUnitName(object obj, Type quantityType)
+        {
+// Mass => "MassUnit.Kilogram"
+            PropertyInfo unitProperty = quantityType
+#if (NETSTANDARD1_0)
+                    .GetTypeInfo()
+                    .GetDeclaredProperty("Unit");
+#else
+                .GetProperty("BaseUnit");
+#endif
+
+            // Unit property value
+            var quantityUnit = (Enum) unitProperty.GetValue(obj, null); // MassUnit.Kilogram
+            Type unitType = quantityUnit.GetType(); // MassUnit
+            string quantityUnitName = $"{unitType.Name}.{quantityUnit}"; // "MassUnit.Kilogram"
+            return quantityUnitName;
+        }
+
+        private static object GetValueOfQuantity(object value, Type quantityType)
+        {
+            FieldInfo valueField = GetPrivateInstanceField(quantityType, ValueFieldName);
+
+            // Unit base type can be double, long or decimal,
+            // so make sure we serialize the real type to avoid
+            // loss of precision
+            object quantityValue = valueField.GetValue(value);
+            return quantityValue;
+        }
+
+        private static FieldInfo GetPrivateInstanceField(Type quantityType, string fieldName)
+        {
             FieldInfo baseValueField;
             try
             {
-                baseValueField = unitType
+                baseValueField = quantityType
 #if (NETSTANDARD1_0)
                     .GetTypeInfo()
-
                     .DeclaredFields
-                    .SingleOrDefault(f => !f.IsPublic && !f.IsStatic);
+                    .Where(f => !f.IsPublic && !f.IsStatic)
 #else
                     .GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
-                    .SingleOrDefault();
 #endif
+                    .SingleOrDefault(f => f.Name == fieldName);
             }
             catch (InvalidOperationException)
             {
-                var ex = new UnitsNetException("Expected exactly 1 private field, but found multiple.");
-                ex.Data["type"] = unitType;
+                var ex = new UnitsNetException($"Expected exactly one private field named [{fieldName}], but found multiple.");
+                ex.Data["type"] = quantityType;
+                ex.Data["fieldName"] = fieldName;
                 throw ex;
             }
+
             if (baseValueField == null)
             {
                 var ex = new UnitsNetException("No private fields found in type.");
-                ex.Data["type"] = unitType;
+                ex.Data["type"] = quantityType;
+                ex.Data["fieldName"] = fieldName;
                 throw ex;
             }
-            // Unit base type can be double, long or decimal,
-            // so make sure we serialize the real type to avoid
-            // loss of precision
-            object baseValue = baseValueField.GetValue(value);
-
-            // Mass => "MassUnit.Kilogram"
-            PropertyInfo baseUnitPropInfo = unitType
-#if (NETSTANDARD1_0)
-                    .GetTypeInfo()
-                    .GetDeclaredProperty("BaseUnit");
-#else
-                .GetProperty("BaseUnit");
-#endif
-
-            // Read static BaseUnit property value
-            var baseUnitEnumValue = (Enum) baseUnitPropInfo.GetValue(null, null);
-            Type baseUnitType = baseUnitEnumValue.GetType();
-            string baseUnit = $"{baseUnitType.Name}.{baseUnitEnumValue}";
 
-            serializer.Serialize(writer, new ValueUnit
-            {
-                // This might throw OverflowException for very large values?
-                // TODO Should we serialize long, decimal and long differently?
-                Value = Convert.ToDouble(baseValue),
-                Unit = baseUnit
-            });
+            return baseValueField;
         }
 
         /// <summary>
@@ -261,7 +313,7 @@ public override bool CanConvert(Type objectType)
         /// </summary>
         /// <param name="objectType">Type of the object.</param>
         /// <returns><c>true</c> if the object type is nullable; otherwise <c>false</c>.</returns>
-        protected bool IsNullable(Type objectType)
+        private static bool IsNullable(Type objectType)
         {
             return Nullable.GetUnderlyingType(objectType) != null;
         }
@@ -280,4 +332,4 @@ protected virtual bool CanConvertNullable(Type objectType)
 
 #endregion
     }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -51,24 +51,35 @@ public class Serialize : UnitsNetJsonConverterTests`
`51`	`51`	`public void Information_CanSerializeVeryLargeValues()`
`52`	`52`	`{`
`53`	`53`	`Information i = Information.FromExabytes(1E+9);`
`54`		`- var expectedJson = "{\n \"Unit\": \"InformationUnit.Bit\",\n \"Value\": 8E+27\n}";`
	`54`	`+ var expectedJson = "{\n \"Unit\": \"InformationUnit.Exabyte\",\n \"Value\": 1000000000.0\n}";`
`55`	`55`
`56`	`56`	`string json = SerializeObject(i);`
`57`	`57`
`58`	`58`	`Assert.Equal(expectedJson, json);`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`[Fact]`
`62`		`- public void Mass_ExpectKilogramsUsedAsBaseValueAndUnit()`
	`62`	`+ public void Mass_ExpectConstructedValueAndUnit()`
`63`	`63`	`{`
`64`	`64`	`Mass mass = Mass.FromPounds(200);`
`65`		`- var expectedJson = "{\n \"Unit\": \"MassUnit.Kilogram\",\n \"Value\": 90.718474\n}";`
	`65`	`+ var expectedJson = "{\n \"Unit\": \"MassUnit.Pound\",\n \"Value\": 200.0\n}";`
`66`	`66`
`67`	`67`	`string json = SerializeObject(mass);`
`68`	`68`
`69`	`69`	`Assert.Equal(expectedJson, json);`
`70`	`70`	`}`
`71`	`71`
	`72`	`+ [Fact]`
	`73`	`+ public void Information_ExpectConstructedValueAndUnit()`
	`74`	`+ {`
	`75`	`+ Information quantity = Information.FromKilobytes(54);`
	`76`	`+ var expectedJson = "{\n \"Unit\": \"InformationUnit.Kilobyte\",\n \"Value\": 54.0\n}";`
	`77`	`+`
	`78`	`+ string json = SerializeObject(quantity);`
	`79`	`+`
	`80`	`+ Assert.Equal(expectedJson, json);`
	`81`	`+ }`
	`82`	`+`
`72`	`83`	`[Fact]`
`73`	`84`	`public void NonNullNullableValue_ExpectJsonUnaffected()`
`74`	`85`	`{`
`@@ -122,7 +133,7 @@ public void NullValue_ExpectJsonContainsNullString()`
`122`	`133`	`public void Ratio_ExpectDecimalFractionsUsedAsBaseValueAndUnit()`
`123`	`134`	`{`
`124`	`135`	`Ratio ratio = Ratio.FromPartsPerThousand(250);`
`125`		`- var expectedJson = "{\n \"Unit\": \"RatioUnit.DecimalFraction\",\n \"Value\": 0.25\n}";`
	`136`	`+ var expectedJson = "{\n \"Unit\": \"RatioUnit.PartPerThousand\",\n \"Value\": 250.0\n}";`
`126`	`137`
`127`	`138`	`string json = SerializeObject(ratio);`
`128`	`139`
`@@ -376,4 +387,4 @@ private class TestObjWithThreeIComparable`
`376`	`387`	`public IComparable Value3 { get; set; }`
`377`	`388`	`}`
`378`	`389`	`}`
`379`		`-}`
	`390`	`+}`