UnitConverter: Throw custom exceptions if types or enum values not found

Add QuantityNotFoundException
Add UnitNotFoundException
Add test cases for invalid quantity and unit input

Author: angularsen

UnitsNet.Tests/UnitConverterTest.cs

@@ -35,6 +35,21 @@ public void ConvertByName_ConvertsTheValueToGivenUnit(double expectedValue, doub
             Assert.Equal(expectedValue, UnitConverter.ConvertByName(inputValue, quantityTypeName, fromUnit, toUnit));
         }
 
+        [Theory]
+        [InlineData(1, "UnknownQuantity", "Meter", "Centimeter")]
+        public void ConvertByName_ThrowsQuantityNotFoundExceptionOnUnknownQuantity(double inputValue, string quantityTypeName, string fromUnit, string toUnit)
+        {
+            Assert.Throws<QuantityNotFoundException>(() => UnitConverter.ConvertByName(inputValue, quantityTypeName, fromUnit, toUnit));
+        }
+
+        [Theory]
+        [InlineData(1, "Length", "UnknownFromUnit", "Centimeter")]
+        [InlineData(1, "Length", "Meter", "UnknownToUnit")]
+        public void ConvertByName_ThrowsUnitNotFoundExceptionOnUnknownFromOrToUnit(double inputValue, string quantityTypeName, string fromUnit, string toUnit)
+        {
+            Assert.Throws<UnitNotFoundException>(() => UnitConverter.ConvertByName(inputValue, quantityTypeName, fromUnit, toUnit));
+        }
+
         [Theory]
         [InlineData(1, "UnknownQuantity", "Meter", "Centimeter")]
         [InlineData(1, "Length", "UnknownFromUnit", "Centimeter")]
@@ -67,6 +82,21 @@ public void ConvertByAbbreviation_ConvertsTheValueToGivenUnit(double expectedVal
             Assert.Equal(expectedValue, UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit));
         }
 
+        [Theory]
+        [InlineData(1, "UnknownQuantity", "m", "cm")]
+        public void ConvertByAbbreviation_ThrowsQuantityNotFoundExceptionOnUnknownQuantity(double inputValue, string quantityTypeName, string fromUnit, string toUnit)
+        {
+            Assert.Throws<QuantityNotFoundException>(() => UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit));
+        }
+
+        [Theory]
+        [InlineData(1, "Length", "UnknownFromUnit", "cm")]
+        [InlineData(1, "Length", "m", "UnknownToUnit")]
+        public void ConvertByAbbreviation_ThrowsUnitNotFoundExceptionOnUnknownFromOrToUnitAbbreviation(double inputValue, string quantityTypeName, string fromUnit, string toUnit)
+        {
+            Assert.Throws<UnitNotFoundException>(() => UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit));
+        }
+
         [Theory]
         [InlineData(1, "UnknownQuantity", "m", "cm")]
         [InlineData(1, "Length", "UnknownFromUnit", "cm")]

UnitsNet/QuantityNotFoundException.cs

@@ -0,0 +1,49 @@
+// Copyright © 2007 Andreas Gullberg Larsen ([email protected]).
+// https://github.com/anjdreas/UnitsNet
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+
+namespace UnitsNet
+{
+    /// <summary>
+    ///     Quantity type was not found. This is typically thrown for dynamic conversions,
+    ///     such as <see cref="UnitConverter.ConvertByName" />.
+    /// </summary>
+#if WINDOWS_UWP
+    internal
+#else
+    public
+#endif
+        class QuantityNotFoundException : UnitsNetException
+    {
+        public QuantityNotFoundException()
+        {
+        }
+
+        public QuantityNotFoundException(string message) : base(message)
+        {
+        }
+
+        public QuantityNotFoundException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+    }
+}

UnitsNet/UnitConverter.cs

@@ -69,13 +69,15 @@ public static class UnitConverter
         /// </param>
         /// <example>double centimeters = ConvertByName(5, "Length", "Meter", "Centimeter"); // 500</example>
         /// <returns>Output value as the result of converting to <paramref name="toUnit" />.</returns>
+        /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
+        /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbrevation.</exception>
         public static double ConvertByName(double fromValue, string quantityName, string fromUnit, string toUnit)
         {
-            Type quantityType = UnitsNetAssembly.GetType($"{QuantityNamespace}.{quantityName}"); // ex: UnitsNet.Length struct
-            Type unitType = UnitsNetAssembly.GetType($"{UnitTypeNamespace}.{quantityName}Unit"); // ex: UnitsNet.Units.LengthUnit enum
+            Type quantityType = GetQuantityType(quantityName);
+            Type unitType = GetUnitType(quantityName);
 
-            object fromUnitValue = Enum.Parse(unitType, fromUnit); // ex: LengthUnit.Meter
-            object toUnitValue = Enum.Parse(unitType, toUnit); // ex: LengthUnit.Centimeter
+            object fromUnitValue = ParseUnit(unitType, fromUnit); // ex: LengthUnit.Meter
+            object toUnitValue = ParseUnit(unitType, toUnit); // ex: LengthUnit.Centimeter
 
             MethodInfo fromMethod = GetStaticFromMethod(quantityType, unitType); // ex: UnitsNet.Length.From(double inputValue, LengthUnit inputUnit)
             object fromResult = fromMethod.Invoke(null, new[] {fromValue, fromUnitValue}); // ex: Length quantity = UnitsNet.Length.From(5, LengthUnit.Meter)
@@ -117,6 +119,8 @@ public static bool TryConvertByName(double inputValue, string quantityName, stri
         {
             try
             {
+                // TODO Reimplement to avoid exceptions where possible, as Try methods are generally recommended for performance and this is cheating
+                // https://msdn.microsoft.com/en-us/library/ms229009(v=vs.100).aspx
                 result = ConvertByName(inputValue, quantityName, fromUnit, toUnit);
                 return true;
             }
@@ -187,10 +191,13 @@ public static double ConvertByAbbreviation(double fromValue, string quantityName
         /// <param name="culture">Culture to parse abbreviations with.</param>
         /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
         /// <returns>Output value as the result of converting to <paramref name="toUnitAbbrev" />.</returns>
+        /// <exception cref="QuantityNotFoundException">No quantity types match the <paramref name="quantityName"/>.</exception>
+        /// <exception cref="UnitNotFoundException">No unit types match the prefix of <paramref name="quantityName"/> or no units are mapped to the abbreviation.</exception>
+        /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbrevation.</exception>
         public static double ConvertByAbbreviation(double fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, string culture)
         {
-            Type quantityType = UnitsNetAssembly.GetType($"{QuantityNamespace}.{quantityName}"); // ex: UnitsNet.Length struct
-            Type unitType = UnitsNetAssembly.GetType($"{UnitTypeNamespace}.{quantityName}Unit"); // ex: UnitsNet.Units.LengthUnit enum
+            Type quantityType = GetQuantityType(quantityName);
+            Type unitType = GetUnitType(quantityName);
 
             UnitSystem unitSystem = UnitSystem.GetCached(culture);
             object fromUnitValue = unitSystem.Parse(fromUnitAbbrev, unitType); // ex: ("m", LengthUnit) => LengthUnit.Meter
@@ -270,6 +277,8 @@ public static bool TryConvertByAbbreviation(double fromValue, string quantityNam
         {
             try
             {
+                // TODO Reimplement to avoid exceptions where possible, as Try methods are generally recommended for performance and this is cheating
+                // https://msdn.microsoft.com/en-us/library/ms229009(v=vs.100).aspx
                 result = ConvertByAbbreviation(fromValue, quantityName, fromUnitAbbrev, toUnitAbbrev, culture);
                 return true;
             }
@@ -321,5 +330,47 @@ private static bool HasParameterTypes(MethodInfo methodInfo, params Type[] expec
 
             return true;
         }
+
+
+        /// <summary>
+        ///     Parse a unit by the unit enum type <paramref name="unitType" /> and a unit enum value <paramref name="unitName" />>
+        /// </summary>
+        /// <param name="unitType">Unit type, such as <see cref="LengthUnit" />.</param>
+        /// <param name="unitName">Unit name, such as "Meter" corresponding to <see cref="LengthUnit.Meter" />.</param>
+        /// <returns>Unit enum value, such as <see cref="LengthUnit.Meter" /> boxed as an object.</returns>
+        /// <exception cref="UnitNotFoundException">No unit values match the <paramref name="unitName" />.</exception>
+        private static object ParseUnit(Type unitType, string unitName)
+        {
+            object unitValue; // ex: LengthUnit.Meter
+            try
+            {
+                unitValue = Enum.Parse(unitType, unitName);
+            }
+            catch (Exception e)
+            {
+                var e2 = new UnitNotFoundException($"Unit not found [{unitName}].", e);
+                e2.Data["unitName"] = unitName;
+                throw e2;
+            }
+            return unitValue;
+        }
+
+        private static Type GetUnitType(string quantityName)
+        {
+            string unitTypeName = $"{UnitTypeNamespace}.{quantityName}Unit";
+            Type unitType = UnitsNetAssembly.GetType(unitTypeName); // ex: UnitsNet.Units.LengthUnit enum
+            if (unitType == null)
+                throw new UnitNotFoundException($"Unit type name not found: {unitTypeName}");
+            return unitType;
+        }
+
+        private static Type GetQuantityType(string quantityName)
+        {
+            string quantityTypeName = $"{QuantityNamespace}.{quantityName}";
+            Type quantityType = UnitsNetAssembly.GetType(quantityTypeName); // ex: UnitsNet.Length struct
+            if (quantityType == null)
+                throw new QuantityNotFoundException($"Quantity type name not found: {quantityTypeName}");
+            return quantityType;
+        }
     }
 }

UnitsNet/UnitNotFoundException.cs

@@ -0,0 +1,49 @@
+// Copyright © 2007 Andreas Gullberg Larsen ([email protected]).
+// https://github.com/anjdreas/UnitsNet
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+
+namespace UnitsNet
+{
+    /// <summary>
+    ///     Unit was not found. This is typically thrown for dynamic conversions,
+    ///     such as <see cref="UnitConverter.ConvertByName" />.
+    /// </summary>
+#if WINDOWS_UWP
+    internal
+#else
+    public
+#endif
+        class UnitNotFoundException : UnitsNetException
+    {
+        public UnitNotFoundException()
+        {
+        }
+
+        public UnitNotFoundException(string message) : base(message)
+        {
+        }
+
+        public UnitNotFoundException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+    }
+}