Insensitive case comparison.

Author: TrevorVonSeggern

UnitsNet.Tests/UnitConverterTest.cs

@@ -26,6 +26,7 @@ namespace UnitsNet.Tests
     public class UnitConverterTest
     {
         [Theory]
+        [InlineData(0, 0, "length", "meter", "centimeter")]
         [InlineData(0, 0, "Length", "Meter", "Centimeter")]
         [InlineData(100, 1, "Length", "Meter", "Centimeter")]
         [InlineData(1, 1000, "Mass", "Gram", "Kilogram")]
@@ -35,6 +36,18 @@ public void ConvertByName_ConvertsTheValueToGivenUnit(double expectedValue, doub
             Assert.Equal(expectedValue, UnitConverter.ConvertByName(inputValue, quantityTypeName, fromUnit, toUnit));
         }
 
+        [Fact]
+        public void ConvertByName__QuantityCaseInsensitive()
+        {
+            Assert.Equal(0, UnitConverter.ConvertByName(0, "length", "Meter", "Centimeter"));
+        }
+
+        [Fact]
+        public void ConvertByName__UnitTypeCaseInsensitive()
+        {
+            Assert.Equal(0, UnitConverter.ConvertByName(0, "Length", "meter", "Centimeter"));
+        }
+
         [Theory]
         [InlineData(1, "UnknownQuantity", "Meter", "Centimeter")]
         public void ConvertByName_ThrowsQuantityNotFoundExceptionOnUnknownQuantity(double inputValue, string quantityTypeName, string fromUnit, string toUnit)

UnitsNet.Tests/UnitParserTests.cs

@@ -41,6 +41,23 @@ public void Parse_ReturnsUnitMappedByCustomAbbreviation(string customAbbreviatio
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void Parse_AbbreviationCaseInsensitive()
+        {
+            var abbreviation = "years";
+            var expected = DurationUnit.Year365;
+            var parser = UnitParser.Default;
+
+            var actual = parser.Parse<DurationUnit>(abbreviation);
+
+            Assert.Equal(expected, actual);
+
+            abbreviation = "Years";
+            actual = parser.Parse<DurationUnit>(abbreviation);
+
+            Assert.Equal(expected, actual);
+        }
+
         [Fact]
         public void Parse_UnknownAbbreviationThrowsUnitNotFoundException()
         {

UnitsNet/CustomCode/UnitValueAbbreviationLookup.cs

@@ -63,10 +63,9 @@ internal List<string> GetAbbreviationsForUnit(int unit)
 
         internal List<int> GetUnitsForAbbreviation(string abbreviation)
         {
-            if(!abbreviationToUnitMap.TryGetValue(abbreviation, out var units))
-                abbreviationToUnitMap[abbreviation] = units = new List<int>();
-
-            return units.Distinct().ToList();
+            return abbreviationToUnitMap
+                .Where(x => x.Key.Equals(abbreviation, StringComparison.InvariantCultureIgnoreCase))
+                .SelectMany(x => x.Value).Distinct().ToList();
         }
 
         internal void Add(int unit, string abbreviation, bool setAsDefault = false)

UnitsNet/UnitConverter.cs

@@ -20,6 +20,7 @@
 // THE SOFTWARE.
 
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
@@ -384,8 +385,9 @@ private static bool HasParameterTypes(MethodInfo methodInfo, params Type[] expec
         private static bool TryParseUnit(Type unitType, string unitName, out object unitValue)
         {
             unitValue = null;
-
-            if(!Enum.IsDefined(unitType, unitName))
+            var eNames = Enum.GetNames(unitType);
+            unitName = eNames.FirstOrDefault(x => x.Equals(unitName, StringComparison.InvariantCultureIgnoreCase));
+            if(unitName is null)
                 return false;
 
             unitValue = Enum.Parse(unitType, unitName);
@@ -395,22 +397,30 @@ private static bool TryParseUnit(Type unitType, string unitName, out object unit
             return true;
         }
 
+        private static List<Type> UnitTypes = UnitsNetAssembly.ExportedTypes
+            .Where(x => x.FullName.StartsWith(UnitTypeNamespace))
+            .ToList();
+
         private static bool TryGetUnitType(string quantityName, out Type unitType)
         {
-            string unitTypeName = $"{UnitTypeNamespace}.{quantityName}Unit";
+            quantityName += "Unit";
+            unitType = QuantityTypes.FirstOrDefault(x => 
+                x.Name.Equals(quantityName, StringComparison.InvariantCultureIgnoreCase));
 
-            unitType = UnitsNetAssembly.GetType(unitTypeName); // ex: UnitsNet.Units.LengthUnit enum
             if(unitType == null)
                 return false;
 
             return true;
         }
 
+        private static List<Type> QuantityTypes = UnitsNetAssembly.ExportedTypes
+            .Where(x => x.FullName.StartsWith(QuantityNamespace))
+            .ToList();
+
         private static bool TryGetQuantityType(string quantityName, out Type quantityType)
         {
-            string quantityTypeName = $"{QuantityNamespace}.{quantityName}";
-
-            quantityType = UnitsNetAssembly.GetType(quantityTypeName); // ex: UnitsNet.Length struct
+            quantityType = QuantityTypes.FirstOrDefault(x => x.Name.Equals(quantityName, StringComparison.InvariantCultureIgnoreCase));
+            
             if(quantityType == null)
                 return false;