Dynamic unit conversions

CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs

@@ -904,6 +904,17 @@ IQuantity IQuantity.ToUnit(Enum unit)
             }}
         }}
 
+        /// <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);
+        }}
+
         private {_valueType} GetValueAs({_unitEnumName} unit)
         {{
             if(Unit == unit)

CodeGen/Generators/UnitsNetGen/UnitConverterGenerator.cs

@@ -0,0 +1,56 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen ([email protected]). Maintained at https://github.com/angularsen/UnitsNet.
+
+using CodeGen.Helpers;
+using CodeGen.JsonTypes;
+
+namespace CodeGen.Generators.UnitsNetGen
+{
+    internal class UnitConverterGenerator : GeneratorBase
+    {
+        private readonly Quantity[] _quantities;
+
+        public UnitConverterGenerator(Quantity[] quantities)
+        {
+            _quantities = quantities;
+        }
+
+        public override string Generate()
+        {
+            Writer.WL(GeneratedFileHeader);
+            Writer.WL($@"
+using UnitsNet.Units;
+
+// ReSharper disable RedundantCommaInArrayInitializer
+// ReSharper disable once CheckNamespace
+
+namespace UnitsNet
+{{
+    public sealed partial class UnitConverter
+    {{
+        /// <summary>
+        /// Registers the default conversion functions in the given <see cref=""UnitConverter""/> instance.
+        /// </summary>
+        /// <param name=""unitConverter"">The <see cref=""UnitConverter""/> to register the default conversion functions in.</param>
+        public static void RegisterDefaultConversions(UnitConverter unitConverter)
+        {{");
+            foreach (Quantity quantity in _quantities)
+            foreach (Unit unit in quantity.Units)
+            {
+                Writer.WL(quantity.BaseUnit == unit.SingularName
+                    ? $@"
+            unitConverter.SetConversionFunction<{quantity.Name}>({quantity.Name}.BaseUnit, {quantity.Name}.BaseUnit, q => q);"
+                    : $@"
+            unitConverter.SetConversionFunction<{quantity.Name}>({quantity.Name}.BaseUnit, {quantity.Name}Unit.{unit.SingularName}, q => q.ToUnit({quantity.Name}Unit.{unit.SingularName}));
+            unitConverter.SetConversionFunction<{quantity.Name}>({quantity.Name}Unit.{unit.SingularName}, {quantity.Name}.BaseUnit, q => q.ToBaseUnit());");
+            }
+
+            Writer.WL($@"
+        }}
+    }}
+}}");
+
+            return Writer.ToString();
+        }
+    }
+}

CodeGen/Generators/UnitsNetGenerator.cs

@@ -58,6 +58,7 @@ public static void Generate(string rootDir, Quantity[] quantities)
             GenerateUnitAbbreviationsCache(quantities, $"{outputDir}/UnitAbbreviationsCache.g.cs");
             GenerateQuantityType(quantities, $"{outputDir}/QuantityType.g.cs");
             GenerateStaticQuantity(quantities, $"{outputDir}/Quantity.g.cs");
+            GenerateUnitConverter(quantities, $"{outputDir}/UnitConverter.g.cs");
 
             var unitCount = quantities.SelectMany(q => q.Units).Count();
             Log.Information("");
@@ -119,5 +120,12 @@ private static void GenerateStaticQuantity(Quantity[] quantities, string filePat
             File.WriteAllText(filePath, content, Encoding.UTF8);
             Log.Information("Quantity.g.cs: ".PadRight(AlignPad) + "(OK)");
         }
+
+        private static void GenerateUnitConverter(Quantity[] quantities, string filePath)
+        {
+            var content = new UnitConverterGenerator(quantities).Generate();
+            File.WriteAllText(filePath, content, Encoding.UTF8);
+            Log.Information("UnitConverter.g.cs: ".PadRight(AlignPad) + "(OK)");
+        }
     }
 }

UnitsNet.Tests/UnitConverterTest.cs

@@ -1,12 +1,115 @@
 // Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen ([email protected]). Maintained at https://github.com/angularsen/UnitsNet.
 
+using System;
+using UnitsNet.Tests.CustomQuantities;
+using UnitsNet.Units;
 using Xunit;
 
 namespace UnitsNet.Tests
 {
     public class UnitConverterTest
     {
+        [Fact]
+        public void CustomConversionWithSameQuantityType()
+        {
+            Length ConversionFunction(Length from) => Length.FromInches(18);
+
+            var unitConverter = new UnitConverter();
+            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch, ConversionFunction);
+
+            var foundConversionFunction = unitConverter.GetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch);
+            var converted = foundConversionFunction(Length.FromMeters(1.0));
+
+            Assert.Equal(Length.FromInches(18), converted);
+        }
+
+        [Fact]
+        public void CustomConversionWithSameQuantityTypeByTypeParam()
+        {
+            Length ConversionFunction(Length from) => Length.FromInches(18);
+
+            var unitConverter = new UnitConverter();
+            unitConverter.SetConversionFunction(LengthUnit.Meter, LengthUnit.Inch, (ConversionFunction<Length>) ConversionFunction);
+
+            var foundConversionFunction = unitConverter.GetConversionFunction(typeof(Length), LengthUnit.Meter, typeof(Length), LengthUnit.Inch);
+            var converted = foundConversionFunction(Length.FromMeters(1.0));
+
+            Assert.Equal(Length.FromInches(18), converted);
+        }
+
+        [Fact]
+        public void CustomConversionWithDifferentQuantityTypes()
+        {
+            IQuantity ConversionFunction(IQuantity from) => Length.FromInches(18);
+
+            var unitConverter = new UnitConverter();
+            unitConverter.SetConversionFunction<Mass, Length>(MassUnit.Grain, LengthUnit.Inch, ConversionFunction);
+
+            var foundConversionFunction = unitConverter.GetConversionFunction<Mass, Length>(MassUnit.Grain, LengthUnit.Inch);
+            var converted = foundConversionFunction(Mass.FromGrains(100));
+
+            Assert.Equal(Length.FromInches(18), converted);
+        }
+
+        [Fact]
+        public void CustomConversionWithDifferentQuantityTypesByTypeParam()
+        {
+            IQuantity ConversionFunction(IQuantity from) => Length.FromInches(18);
+
+            var unitConverter = new UnitConverter();
+            unitConverter.SetConversionFunction<Mass, Length>(MassUnit.Grain, LengthUnit.Inch, ConversionFunction);
+
+            var foundConversionFunction = unitConverter.GetConversionFunction(typeof(Mass), MassUnit.Grain, typeof(Length), LengthUnit.Inch);
+            var converted = foundConversionFunction(Mass.FromGrains(100));
+
+            Assert.Equal(Length.FromInches(18), converted);
+        }
+
+        [Fact]
+        public void TryCustomConversionForOilBarrelsToUsGallons()
+        {
+            Volume ConversionFunction(Volume from) => Volume.FromUsGallons(from.Value * 42);
+
+            var unitConverter = new UnitConverter();
+            unitConverter.SetConversionFunction<Volume>(VolumeUnit.OilBarrel, VolumeUnit.UsGallon, ConversionFunction);
+
+            var foundConversionFunction = unitConverter.GetConversionFunction<Volume>(VolumeUnit.OilBarrel, VolumeUnit.UsGallon);
+            var converted = foundConversionFunction(Volume.FromOilBarrels(1));
+
+            Assert.Equal(Volume.FromUsGallons(42), converted);
+        }
+
+        [Fact]
+        public void ConversionToSameUnit_ReturnsSameQuantity()
+        {
+            var unitConverter = new UnitConverter();
+
+            var foundConversionFunction = unitConverter.GetConversionFunction<HowMuch>(HowMuchUnit.ATon, HowMuchUnit.ATon);
+            var converted = foundConversionFunction(new HowMuch(39, HowMuchUnit.Some)); // Intentionally pass the wrong unit here, to test that the exact same quantity is returned
+
+            Assert.Equal(39, converted.Value);
+            Assert.Equal(HowMuchUnit.Some, converted.Unit);
+        }
+
+        [Theory]
+        [InlineData(1, HowMuchUnit.Some, HowMuchUnit.Some, 1)]
+        [InlineData(1, HowMuchUnit.Some, HowMuchUnit.ATon, 2)]
+        [InlineData(1, HowMuchUnit.Some, HowMuchUnit.AShitTon, 10)]
+        public void ConversionForUnitsOfCustomQuantity(double fromValue, Enum fromUnit, Enum toUnit, double expectedValue)
+        {
+            // Intentionally don't map conversion Some->Some, it is not necessary
+            var unitConverter = new UnitConverter();
+            unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Some, HowMuchUnit.ATon, x => new HowMuch(x.Value * 2, HowMuchUnit.ATon));
+            unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Some, HowMuchUnit.AShitTon, x => new HowMuch(x.Value * 10, HowMuchUnit.AShitTon));
+
+            var foundConversionFunction = unitConverter.GetConversionFunction<HowMuch>(fromUnit, toUnit);
+            var converted = foundConversionFunction(new HowMuch(fromValue, fromUnit));
+
+            Assert.Equal(expectedValue, converted.Value);
+            Assert.Equal(toUnit, converted.Unit);
+        }
+
         [Theory]
         [InlineData(0, 0, "length", "meter", "centimeter")]
         [InlineData(0, 0, "Length", "Meter", "Centimeter")]

UnitsNet.Tests/UnitParserTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using UnitsNet.Tests.CustomQuantities;
 using UnitsNet.Units;
 using Xunit;
 
@@ -124,5 +125,17 @@ public void ParseMassUnit_GivenCulture(string str, string cultureName, Enum expe
         {
             Assert.Equal(expectedUnit, UnitParser.Default.Parse<MassUnit>(str, new CultureInfo(cultureName)));
         }
+
+        [Fact]
+        public void Parse_MappedCustomUnit()
+        {
+            var unitAbbreviationsCache = new UnitAbbreviationsCache();
+            unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.Some, "fooh");
+            var unitParser = new UnitParser(unitAbbreviationsCache);
+
+            var parsedUnit = unitParser.Parse<HowMuchUnit>("fooh");
+
+            Assert.Equal(HowMuchUnit.Some, parsedUnit);
+        }
     }
 }

UnitsNet/CustomCode/QuantityParser.cs

@@ -25,7 +25,7 @@ internal class QuantityParser
         private const NumberStyles ParseNumberStyles = NumberStyles.Number | NumberStyles.Float | NumberStyles.AllowExponent;
 
         private readonly UnitAbbreviationsCache _unitAbbreviationsCache;
-        private UnitParser _unitParser;
+        private readonly UnitParser _unitParser;
 
         public static QuantityParser Default { get; }