Use UnitConverter to do conversion functions and allow basic extensibility (#1023)

Author: tmilnthorp

CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs

@@ -164,6 +164,8 @@ private void GenerateStaticConstructor()
             Writer.WL($@"
                 }},
                 BaseUnit, Zero, BaseDimensions, QuantityType.{_quantity.Name});
+
+            RegisterDefaultConversions(DefaultConversionFunctions);
         }}
 ");
         }
@@ -213,9 +215,9 @@ private void GenerateInstanceConstructors()
             _value = Guard.EnsureValidNumber(value, nameof(value));"
                 : @"
             _value = value;");
-            Writer.WL(@"
+            Writer.WL($@"
             _unit = firstUnitInfo?.Value ?? throw new ArgumentException(""No units were found for the given UnitSystem."", nameof(unitSystem));
-        }
+        }}
 ");
         }
 
@@ -224,6 +226,11 @@ private void GenerateStaticProperties()
             Writer.WL($@"
         #region Static Properties
 
+        /// <summary>
+        ///     The <see cref=""UnitConverter"" /> containing the default generated conversion functions for <see cref=""{_quantity.Name}"" /> instances.
+        /// </summary>
+        public static UnitConverter DefaultConversionFunctions {{ get; }} = new UnitConverter();
+
         /// <inheritdoc cref=""IQuantity.QuantityInfo""/>
         public static QuantityInfo<{_unitEnumName}> Info {{ get; }}
 
@@ -360,27 +367,29 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter)
             if(unit.SingularName == _quantity.BaseUnit)
                 continue;
 
-            Writer.WL( $@"
-            unitConverter.SetConversionFunction<{_quantity.Name}>({_unitEnumName}.{_quantity.BaseUnit}, {_quantity.Name}Unit.{unit.SingularName}, quantity => quantity.ToUnit({_quantity.Name}Unit.{unit.SingularName}));");
+        var func = unit.FromBaseToUnitFunc.Replace("{x}", "quantity.Value");
+        Writer.WL($@"
+            unitConverter.SetConversionFunction<{_quantity.Name}>({_unitEnumName}.{_quantity.BaseUnit}, {_quantity.Name}Unit.{unit.SingularName}, quantity => new {_quantity.Name}({func}, {_quantity.Name}Unit.{unit.SingularName}));");
         }
 
-        Writer.WL( $@"
+        Writer.WL($@"
             
             // Register in unit converter: BaseUnit <-> BaseUnit
             unitConverter.SetConversionFunction<{_quantity.Name}>({_unitEnumName}.{_quantity.BaseUnit}, {_unitEnumName}.{_quantity.BaseUnit}, quantity => quantity);
 
-            // Register in unit converter: {_quantity.Name}Unit -> BaseUnit" );
+            // Register in unit converter: {_quantity.Name}Unit -> BaseUnit");
 
         foreach(var unit in _quantity.Units)
         {
             if(unit.SingularName == _quantity.BaseUnit)
                 continue;
 
-            Writer.WL($@"
-            unitConverter.SetConversionFunction<{_quantity.Name}>({_quantity.Name}Unit.{unit.SingularName}, {_unitEnumName}.{_quantity.BaseUnit}, quantity => quantity.ToBaseUnit());" );
+        var func = unit.FromUnitToBaseFunc.Replace("{x}", "quantity.Value");
+        Writer.WL($@"
+            unitConverter.SetConversionFunction<{_quantity.Name}>({_quantity.Name}Unit.{unit.SingularName}, {_unitEnumName}.{_quantity.BaseUnit}, quantity => new {_quantity.Name}({func}, {_unitEnumName}.{_quantity.BaseUnit}));");
         }
 
-        Writer.WL( $@"
+        Writer.WL($@"
         }}
 
         /// <summary>
@@ -903,11 +912,42 @@ double IQuantity.As(Enum unit)
         /// <summary>
         ///     Converts this {_quantity.Name} to another {_quantity.Name} with the unit representation <paramref name=""unit"" />.
         /// </summary>
+        /// <param name=""unit"">The unit to convert to.</param>
         /// <returns>A {_quantity.Name} with the specified unit.</returns>
         public {_quantity.Name} ToUnit({_unitEnumName} unit)
         {{
-            var convertedValue = GetValueAs(unit);
-            return new {_quantity.Name}(convertedValue, unit);
+            return ToUnit(unit, DefaultConversionFunctions);
+        }}
+
+        /// <summary>
+        ///     Converts this {_quantity.Name} to another {_quantity.Name} using the given <paramref name=""unitConverter""/> with the unit representation <paramref name=""unit"" />.
+        /// </summary>
+        /// <param name=""unit"">The unit to convert to.</param>
+        /// <param name=""unitConverter"">The <see cref=""UnitConverter""/> to use for the conversion.</param>
+        /// <returns>A {_quantity.Name} with the specified unit.</returns>
+        public {_quantity.Name} ToUnit({_unitEnumName} unit, UnitConverter unitConverter)
+        {{
+            if(Unit == unit)
+            {{
+                // Already in requested units.
+                return this;
+            }}
+            else if(unitConverter.TryGetConversionFunction((typeof({_quantity.Name}), Unit, typeof({_quantity.Name}), unit), out var conversionFunction))
+            {{
+                // Direct conversion to requested unit found. Return the converted quantity.
+                var converted = conversionFunction(this);
+                return ({_quantity.Name})converted;
+            }}
+            else if(Unit != BaseUnit)
+            {{
+                // Direct conversion to requested unit NOT found. Convert to BaseUnit, and then from BaseUnit to requested unit.
+                var inBaseUnits = ToUnit(BaseUnit);
+                return inBaseUnits.ToUnit(unit);
+            }}
+            else
+            {{
+                throw new NotImplementedException($""Can not convert {{Unit}} to {{unit}}."");
+            }}
         }}
 
         /// <inheritdoc />
@@ -916,7 +956,16 @@ IQuantity IQuantity.ToUnit(Enum unit)
             if(!(unit is {_unitEnumName} unitAs{_unitEnumName}))
                 throw new ArgumentException($""The given unit is of type {{unit.GetType()}}. Only {{typeof({_unitEnumName})}} is supported."", nameof(unit));
 
-            return ToUnit(unitAs{_unitEnumName});
+            return ToUnit(unitAs{_unitEnumName}, DefaultConversionFunctions);
+        }}
+
+        /// <inheritdoc />
+        IQuantity IQuantity.ToUnit(Enum unit, UnitConverter unitConverter)
+        {{
+            if(!(unit is {_unitEnumName} unitAs{_unitEnumName}))
+                throw new ArgumentException($""The given unit is of type {{unit.GetType()}}. Only {{typeof({_unitEnumName})}} is supported."", nameof(unit));
+
+            return ToUnit(unitAs{_unitEnumName}, unitConverter);
         }}
 
         /// <inheritdoc cref=""IQuantity.ToUnit(UnitSystem)""/>
@@ -941,62 +990,16 @@ IQuantity IQuantity.ToUnit(Enum unit)
         IQuantity<{_unitEnumName}> IQuantity<{_unitEnumName}>.ToUnit({_unitEnumName} unit) => ToUnit(unit);
 
         /// <inheritdoc />
-        IQuantity<{_unitEnumName}> IQuantity<{_unitEnumName}>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
+        IQuantity<{_unitEnumName}> IQuantity<{_unitEnumName}>.ToUnit({_unitEnumName} unit, UnitConverter unitConverter) => ToUnit(unit, unitConverter);
 
-        /// <summary>
-        ///     Converts the current value + unit to the base unit.
-        ///     This is typically the first step in converting from one unit to another.
-        /// </summary>
-        /// <returns>The value in the base unit representation.</returns>
-        private {_valueType} GetValueInBaseUnit()
-        {{
-            switch(Unit)
-            {{");
-            foreach (var unit in _quantity.Units)
-            {
-                var func = unit.FromUnitToBaseFunc.Replace("{x}", "_value");
-                Writer.WL($@"
-                case {_unitEnumName}.{unit.SingularName}: return {func};");
-            }
-
-            Writer.WL($@"
-                default:
-                    throw new NotImplementedException($""Can not convert {{Unit}} to base units."");
-            }}
-        }}
-
-        /// <summary>
-        ///     Converts the current value + unit to the base unit.
-        ///     This is typically the first step in converting from one unit to another.
-        /// </summary>
-        /// <returns>The value in the base unit representation.</returns>
-        internal {_quantity.Name} ToBaseUnit()
-        {{
-            var baseUnitValue = GetValueInBaseUnit();
-            return new {_quantity.Name}(baseUnitValue, BaseUnit);
-        }}
+        /// <inheritdoc />
+        IQuantity<{_unitEnumName}> IQuantity<{_unitEnumName}>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
         private {_valueType} GetValueAs({_unitEnumName} unit)
         {{
-            if(Unit == unit)
-                return _value;
-
-            var baseUnitValue = GetValueInBaseUnit();
-
-            switch(unit)
-            {{");
-            foreach (var unit in _quantity.Units)
-            {
-                var func = unit.FromBaseToUnitFunc.Replace("{x}", "baseUnitValue");
-                Writer.WL($@"
-                case {_unitEnumName}.{unit.SingularName}: return {func};");
-            }
-
-            Writer.WL(@"
-                default:
-                    throw new NotImplementedException($""Can not convert {Unit} to {unit}."");
-            }
-        }
+            var converted = ToUnit(unit);
+            return ({_valueType})converted.Value;
+        }}
 
         #endregion
 ");
@@ -1084,7 +1087,7 @@ public string ToString(string format, IFormatProvider? provider)
         }}
 
         #endregion
-" );
+");
         }
 
         private void GenerateIConvertibleMethods()

CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs

@@ -76,6 +76,7 @@ public override string Generate()
             Writer.WL(GeneratedFileHeader);
             Writer.WL($@"
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Threading;
@@ -95,16 +96,37 @@ namespace UnitsNet.Tests
 // ReSharper disable once PartialTypeWithSinglePart
     public abstract partial class {_quantity.Name}TestsBase : QuantityTestsBase
     {{");
-            foreach (var unit in _quantity.Units) Writer.WL($@"
+            foreach(var unit in _quantity.Units) Writer.WL($@"
         protected abstract double {unit.PluralName}InOne{_baseUnit.SingularName} {{ get; }}");
 
             Writer.WL("");
             Writer.WL($@"
 // ReSharper disable VirtualMemberNeverOverriden.Global");
-            foreach (var unit in _quantity.Units) Writer.WL($@"
+            foreach(var unit in _quantity.Units) Writer.WL($@"
         protected virtual double {unit.PluralName}Tolerance {{ get {{ return 1e-5; }} }}"); Writer.WL($@"
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
+        protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor({_unitEnumName} unit)
+        {{
+            return unit switch
+            {{");
+            foreach(var unit in _quantity.Units) Writer.WL($@"
+                {GetUnitFullName(unit)} => ({unit.PluralName}InOne{_baseUnit.SingularName}, {unit.PluralName}Tolerance),");
+            Writer.WL($@"
+                _ => throw new NotSupportedException()
+            }};
+        }}
+
+        public static IEnumerable<object[]> UnitTypes = new List<object[]>
+        {{");
+            foreach(var unit in _quantity.Units)
+            {
+                Writer.WL($@"
+            new object[] {{ {GetUnitFullName(unit)} }},");
+            }
+            Writer.WL($@"
+        }};
+
         [Fact]
         public void Ctor_WithUndefinedUnit_ThrowsArgumentException()
         {{
@@ -116,14 +138,14 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         {{
             var quantity = new {_quantity.Name}();
             Assert.Equal(0, quantity.Value);");
-            if (_quantity.BaseType == "decimal") Writer.WL($@"
+            if(_quantity.BaseType == "decimal") Writer.WL($@"
             Assert.Equal(0m, ((IDecimalQuantity)quantity).Value);");
             Writer.WL($@"
             Assert.Equal({_baseUnitFullName}, quantity.Unit);
         }}
 
 ");
-            if (_quantity.BaseType == "double") Writer.WL($@"
+            if(_quantity.BaseType == "double") Writer.WL($@"
         [Fact]
         public void Ctor_WithInfinityValue_ThrowsArgumentException()
         {{
@@ -183,7 +205,7 @@ public void Ctor_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {{
             {_quantity.Name} {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);");
 
-            foreach (var unit in _quantity.Units) Writer.WL($@"
+            foreach(var unit in _quantity.Units) Writer.WL($@"
             AssertEx.EqualTolerance({unit.PluralName}InOne{_baseUnit.SingularName}, {baseUnitVariableName}.{unit.PluralName}, {unit.PluralName}Tolerance);");
             Writer.WL($@"
         }}
@@ -192,7 +214,7 @@ public void Ctor_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
         public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         {{");
             int i = 0;
-            foreach (var unit in _quantity.Units)
+            foreach(var unit in _quantity.Units)
             {
                 var quantityVariable = $"quantity{i++:D2}";
                 Writer.WL($@"
@@ -205,7 +227,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
             Writer.WL($@"
         }}
 ");
-            if (_quantity.BaseType == "double") Writer.WL($@"
+            if(_quantity.BaseType == "double") Writer.WL($@"
         [Fact]
         public void From{_baseUnit.PluralName}_WithInfinityValue_ThrowsArgumentException()
         {{
@@ -224,7 +246,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
         public void As()
         {{
             var {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);");
-            foreach (var unit in _quantity.Units) Writer.WL($@"
+            foreach(var unit in _quantity.Units) Writer.WL($@"
             AssertEx.EqualTolerance({unit.PluralName}InOne{_baseUnit.SingularName}, {baseUnitVariableName}.As({GetUnitFullName(unit)}), {unit.PluralName}Tolerance);");
             Writer.WL($@"
         }}
@@ -246,29 +268,41 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
             }}
         }}
 
-        [Fact]
-        public void ToUnit()
+        [Theory]
+        [MemberData(nameof(UnitTypes))]
+        public void ToUnit({_unitEnumName} unit)
         {{
-            var {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);");
-            foreach (var unit in _quantity.Units)
-            {
-                var asQuantityVariableName = $"{unit.SingularName.ToLowerInvariant()}Quantity";
+            var inBaseUnits = {_quantity.Name}.From(1.0, {_quantity.Name}.BaseUnit);
+            var converted = inBaseUnits.ToUnit(unit);
 
-                Writer.WL("");
-                Writer.WL($@"
-            var {asQuantityVariableName} = {baseUnitVariableName}.ToUnit({GetUnitFullName(unit)});
-            AssertEx.EqualTolerance({unit.PluralName}InOne{_baseUnit.SingularName}, (double){asQuantityVariableName}.Value, {unit.PluralName}Tolerance);
-            Assert.Equal({GetUnitFullName(unit)}, {asQuantityVariableName}.Unit);");
-            }
-            Writer.WL($@"
+            var conversionFactor = GetConversionFactor(unit);
+            AssertEx.EqualTolerance(conversionFactor.UnitsInBaseUnit, (double)converted.Value, conversionFactor.Tolerence);
+            Assert.Equal(unit, converted.Unit);
         }}
 
-        [Fact]
-        public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
+        [Theory]
+        [MemberData(nameof(UnitTypes))]
+        public void ToUnit_WithSameUnits_AreEqual({_unitEnumName} unit)
         {{
-            var quantityInBaseUnit = {_quantity.Name}.From{_baseUnit.PluralName}(1).ToBaseUnit();
-            Assert.Equal({_quantity.Name}.BaseUnit, quantityInBaseUnit.Unit);");
-            Writer.WL($@"
+            var quantity = {_quantity.Name}.From(3.0, unit);
+            var toUnitWithSameUnit = quantity.ToUnit(unit);
+            Assert.Equal(quantity, toUnitWithSameUnit);
+        }}
+
+        [Theory]
+        [MemberData(nameof(UnitTypes))]
+        public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit({_unitEnumName} unit)
+        {{
+            // See if there is a unit available that is not the base unit.
+            var fromUnit = {_quantity.Name}.Units.FirstOrDefault(u => u != {_quantity.Name}.BaseUnit && u != {_unitEnumName}.Undefined);
+
+            // If there is only one unit for the quantity, we must use the base unit.
+            if(fromUnit == {_unitEnumName}.Undefined)
+                fromUnit = {_quantity.Name}.BaseUnit;
+
+            var quantity = {_quantity.Name}.From(3.0, fromUnit);
+            var converted = quantity.ToUnit(unit);
+            Assert.Equal(converted.Unit, unit);
         }}
 
         [Fact]
@@ -701,9 +735,9 @@ public void GetHashCode_Equals()
         }}
 ");
 
-        if( _quantity.GenerateArithmetic )
+        if(_quantity.GenerateArithmetic)
         {
-                Writer.WL( $@"
+                Writer.WL($@"
         [Theory]
         [InlineData(1.0)]
         [InlineData(-1.0)]
@@ -716,7 +750,7 @@ public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value)
 
 Writer.WL($@"
     }}
-}}" );
+}}");
             return Writer.ToString();
         }
     }