Modified serilization to support units saved as IComparable

UnitsNet.Serialization.JsonNet.Tests/UnitsNetJsonConverterTests.cs

@@ -22,6 +22,7 @@
 using System;
 using Newtonsoft.Json;
 using NUnit.Framework;
+using System.Collections.Generic;
 
 namespace UnitsNet.Serialization.JsonNet.Tests
 {
@@ -226,12 +227,185 @@ public void UnitEnumChangedAfterSerialization_ExpectUnitCorrectlyDeserialized()
                 //  still deserializable, and the correct value of 1000 g is obtained.
                 Assert.That(deserializedMass.Grams, Is.EqualTo(1000));
             }
+
+            [Test]
+            public void UnitInIComparable_ExpectUnitCorrectlyDeserialized()
+            {
+                TestObjWithIComparable testObjWithIComparable = new TestObjWithIComparable()
+                {
+                    Value = Power.FromWatts(10)
+                };
+                JsonSerializerSettings jsonSerializerSettings = CreateJsonSerializerSettigns();
+
+                string json = JsonConvert.SerializeObject(testObjWithIComparable,jsonSerializerSettings);
+
+                var deserializedTestObject = JsonConvert.DeserializeObject<TestObjWithIComparable>(json,jsonSerializerSettings);
+
+                Assert.That(deserializedTestObject.Value.GetType(), Is.EqualTo(typeof(Power)));
+                Assert.That((Power)deserializedTestObject.Value, Is.EqualTo(Power.FromWatts(10)));
+            }
+
+            [Test]
+            public void DoubleInIComparable_ExpectUnitCorrectlyDeserialized()
+            {
+                TestObjWithIComparable testObjWithIComparable = new TestObjWithIComparable()
+                {
+                    Value = 10.0
+                };
+                JsonSerializerSettings jsonSerializerSettings = CreateJsonSerializerSettigns();
+
+                string json = JsonConvert.SerializeObject(testObjWithIComparable, jsonSerializerSettings);
+
+                var deserializedTestObject = JsonConvert.DeserializeObject<TestObjWithIComparable>(json, jsonSerializerSettings);
+
+                Assert.That(deserializedTestObject.Value.GetType(), Is.EqualTo(typeof(double)));
+                Assert.That((double)deserializedTestObject.Value, Is.EqualTo(10.0));
+            }
+
+            [Test]
+            public void ClassInIComparable_ExpectUnitCorrectlyDeserialized()
+            {
+                TestObjWithIComparable testObjWithIComparable = new TestObjWithIComparable()
+                {
+                    Value = new ComparableClass() { Value = 10 }
+                };
+                JsonSerializerSettings jsonSerializerSettings = CreateJsonSerializerSettigns();
+
+                string json = JsonConvert.SerializeObject(testObjWithIComparable, jsonSerializerSettings);
+                var deserializedTestObject = JsonConvert.DeserializeObject<TestObjWithIComparable>(json, jsonSerializerSettings);
+
+                Assert.That(deserializedTestObject.Value.GetType(), Is.EqualTo(typeof(ComparableClass)));
+                Assert.That(((ComparableClass)(deserializedTestObject.Value)).Value, Is.EqualTo(10.0));
+            }
+
+            [Test]
+            public void OtherObjectWithUnitAndValue_ExpectCorrectResturnValues()
+            {
+                TestObjWithValueAndUnit testObjWithValueAndUnit = new TestObjWithValueAndUnit()
+                {
+                   Value = 5,
+                   Unit = "Test",
+                };
+                JsonSerializerSettings jsonSerializerSettings = CreateJsonSerializerSettigns();
+
+                string json = JsonConvert.SerializeObject(testObjWithValueAndUnit, jsonSerializerSettings);
+                TestObjWithValueAndUnit deserializedTestObject = JsonConvert.DeserializeObject<TestObjWithValueAndUnit>(json, jsonSerializerSettings);
+
+                Assert.That(deserializedTestObject.Value.GetType(), Is.EqualTo(typeof(double)));
+                Assert.That(deserializedTestObject.Value, Is.EqualTo(5.0));
+                Assert.That(deserializedTestObject.Unit, Is.EqualTo("Test"));
+            }
+
+            [Test, TestCaseSource(nameof(TestObjectsForThreeObjectsInIComparableWithDifferentValues_ExpectAllCorrectlyDeserialized))]
+            public void ThreeObjectsInIComparableWithDifferentValues_ExpectAllCorrectlyDeserialized(
+                IComparable comparable1,
+                IComparable comparable2,
+                IComparable comparable3)
+            {
+                TestObjWithThreeIComparable testObjWithIComparable = new TestObjWithThreeIComparable()
+                {
+                    Value1 = comparable1,
+                    Value2 = comparable2,
+                    Value3 = comparable3,
+                };
+                JsonSerializerSettings jsonSerializerSettings = CreateJsonSerializerSettigns();
+
+                string json = JsonConvert.SerializeObject(testObjWithIComparable, jsonSerializerSettings);
+                var deserializedTestObject = JsonConvert.DeserializeObject<TestObjWithThreeIComparable>(json, jsonSerializerSettings);
+
+                Assert.That(deserializedTestObject.Value1.GetType(), Is.EqualTo(comparable1.GetType()));
+                Assert.That(((deserializedTestObject.Value1)), Is.EqualTo(comparable1));
+                Assert.That(deserializedTestObject.Value2.GetType(), Is.EqualTo(comparable2.GetType()));
+                Assert.That(((deserializedTestObject.Value2)), Is.EqualTo(comparable2));
+                Assert.That(deserializedTestObject.Value3.GetType(), Is.EqualTo(comparable3.GetType()));
+                Assert.That(((deserializedTestObject.Value3)), Is.EqualTo(comparable3));
+            }
+
+            public static object[] TestObjectsForThreeObjectsInIComparableWithDifferentValues_ExpectAllCorrectlyDeserialized
+            {
+                get
+                {
+                    List<object> result = new List<object>();
+                    var objects = new object[] { 10.0, Power.FromWatts(19), new ComparableClass() { Value = 10 } };
+                    for (int i = 0; i < objects.Length; i++)
+                    {
+                        for (int j = 0; j < objects.Length; j++)
+                        {
+                            for (int k = 0; k < objects.Length; k++)
+                            {
+                                result.Add(new object[] { objects[i], objects[j], objects[k]});
+                            }
+                        }
+                    }
+                    return result.ToArray();
+                }
+            }
+
+            private static JsonSerializerSettings CreateJsonSerializerSettigns()
+            {
+                var jsonSerializerSettings = new JsonSerializerSettings()
+                {
+                    Formatting = Formatting.Indented,
+                    TypeNameHandling = TypeNameHandling.Auto
+                };
+                jsonSerializerSettings.Converters.Add(new UnitsNetJsonConverter());
+                return jsonSerializerSettings;
+            }
         }
 
         internal class TestObj
         {
             public Frequency? NullableFrequency { get; set; }
             public Frequency NonNullableFrequency { get; set; }
         }
+
+        internal class TestObjWithValueAndUnit : IComparable
+        {
+            public double Value { get; set; }
+            public string Unit { get; set; }
+
+            public int CompareTo(object obj)
+            {
+                return Value.CompareTo(obj);
+            }
+        }
+
+        internal class ComparableClass : IComparable
+        {
+            public int Value { get; set; }
+            public int CompareTo(object obj)
+            {
+                return Value.CompareTo(obj);
+            }
+
+            // Needed for virfying that the deserialized object is the same, should not affect the serilization code
+            public override bool Equals(object obj)
+            {
+                if (obj == null || GetType() != obj.GetType())
+                {
+                    return false;
+                }
+                return Value.Equals(((ComparableClass)obj).Value);
+            }
+
+            public override int GetHashCode()
+            {
+                return Value.GetHashCode();
+            }
+        }
+
+        internal class TestObjWithIComparable
+        {
+            public IComparable Value { get; set; }
+        }
+
+        internal class TestObjWithThreeIComparable
+        {
+            public IComparable Value1 { get; set; }
+
+            public IComparable Value2 { get; set; }
+
+            public IComparable Value3 { get; set; }
+        }
     }
 }

UnitsNet.Serialization.JsonNet/UnitsNetJsonConverter.cs

@@ -25,6 +25,7 @@
 using System.Reflection;
 using JetBrains.Annotations;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace UnitsNet.Serialization.JsonNet
 {
@@ -55,10 +56,17 @@ public class UnitsNetJsonConverter : JsonConverter
         public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
             JsonSerializer serializer)
         {
-            var vu = serializer.Deserialize<ValueUnit>(reader);
-            // A null System.Nullable value was deserialized so just return null.
+            if (reader.ValueType != null)
+            {
+                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)
-                return null;
+            {
+                return obj;
+            }
 
             // "MassUnit.Kilogram" => "MassUnit" and "Kilogram"
             string unitEnumTypeName = vu.Unit.Split('.')[0];
@@ -102,10 +110,31 @@ where m.Name.Equals("From", StringComparison.InvariantCulture) &&
             // 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, BindingFlags.Static, null, new[] {vu.Value, unit},
+            return fromMethod.Invoke(null, BindingFlags.Static, null, new[] { vu.Value, unit },
                 CultureInfo.InvariantCulture);
         }
 
+        private static object TryDeserializeIComparable(JsonReader reader, JsonSerializer serializer)
+        {
+            JToken token = JToken.Load(reader);
+            if (!token.HasValues || token[nameof(ValueUnit.Unit)] == null || token[nameof(ValueUnit.Value)] == null)
+            {
+                JsonSerializer localSerializer = new JsonSerializer()
+                {
+                    TypeNameHandling = serializer.TypeNameHandling,
+                };
+                return token.ToObject<IComparable>(localSerializer);
+            }
+            else
+            {
+                return new ValueUnit()
+                {
+                    Unit = token[nameof(ValueUnit.Unit)].ToString(),
+                    Value = token[nameof(ValueUnit.Value)].ToObject<double>()
+                };
+            }
+        }
+
         /// <summary>
         ///     Writes the JSON representation of the object.
         /// </summary>
@@ -117,6 +146,18 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
         {
             Type unitType = value.GetType();
 
+            // ValueUnit should be written as usual (but read in a custom way)
+            if(unitType == typeof(ValueUnit))
+            {
+                JsonSerializer localSerializer = new JsonSerializer()
+                {
+                    TypeNameHandling = serializer.TypeNameHandling,
+                };
+                JToken t = JToken.FromObject(value, localSerializer);
+
+                t.WriteTo(writer);
+                return;
+            }
             FieldInfo[] fields =
                 unitType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
             if (fields.Length == 0)
@@ -184,7 +225,11 @@ public override bool CanConvert(Type objectType)
                 return CanConvertNullable(objectType);
             }
 
-            return objectType.Namespace != null && objectType.Namespace.Equals("UnitsNet");
+            return objectType.Namespace != null &&
+                (objectType.Namespace.Equals(nameof(UnitsNet)) ||
+                objectType == typeof(ValueUnit) ||
+                // All unit types implement IComparable
+                objectType == typeof(IComparable));
         }
 
         /// <summary>
@@ -206,7 +251,7 @@ protected virtual bool CanConvertNullable(Type objectType)
         {
             // Need to look at the FullName in order to determine if the nullable type contains a UnitsNet type.
             // For example: FullName = 'System.Nullable`1[[UnitsNet.Frequency, UnitsNet, Version=3.19.0.0, Culture=neutral, PublicKeyToken=null]]'
-            return objectType.FullName != null && objectType.FullName.Contains("UnitsNet.");
+            return objectType.FullName != null && objectType.FullName.Contains(nameof(UnitsNet) + ".");
         }
 
         #endregion