Case insensitive unit parsing and conversion.

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,30 @@ public void Parse_ReturnsUnitMappedByCustomAbbreviation(string customAbbreviatio
  Assert.Equal(expected, actual);
  }
 
+ [Fact]
+ public void Parse_AbbreviationCaseInsensitive_Lowercase_years()
+ {
+ var abbreviation = "years";
+ var expected = DurationUnit.Year365;
+ var parser = UnitParser.Default;
+
+ var actual = parser.Parse<DurationUnit>(abbreviation);
+
+ Assert.Equal(expected, actual);
+ }
+
+ [Fact]
+ public void Parse_AbbreviationCaseInsensitive_Uppercase_Years()
+ {
+ var abbreviation = "Years";
+ var expected = DurationUnit.Year365;
+ var parser = UnitParser.Default;
+
+ var actual = parser.Parse<DurationUnit>(abbreviation);
+
+ Assert.Equal(expected, actual);
+ }
+
  [Fact]
  public void Parse_UnknownAbbreviationThrowsUnitNotFoundException()
  {

UnitsNet/CustomCode/UnitValueAbbreviationLookup.cs

@@ -1,4 +1,4 @@
-// Copyright (c) 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).
+// Copyright (c) 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).
 // https://github.com/angularsen/UnitsNet
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -63,19 +63,21 @@ 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>();
+ var lowerCaseAbbreviation = abbreviation.ToLower();
+ if(!abbreviationToUnitMap.TryGetValue(lowerCaseAbbreviation, out var units))
+ abbreviationToUnitMap[lowerCaseAbbreviation] = units = new List<int>();
 
  return units.Distinct().ToList();
  }
 
  internal void Add(int unit, string abbreviation, bool setAsDefault = false)
  {
+ var lowerCaseAbbreviation = abbreviation.ToLower();
  if(!unitToAbbreviationMap.TryGetValue(unit, out var abbreviationsForUnit))
  abbreviationsForUnit = unitToAbbreviationMap[unit] = new List<string>();
 
- if(!abbreviationToUnitMap.TryGetValue(abbreviation, out var unitsForAbbreviation))
- abbreviationToUnitMap[abbreviation] = unitsForAbbreviation = new List<int>();
+ if(!abbreviationToUnitMap.TryGetValue(lowerCaseAbbreviation, out var unitsForAbbreviation))
+ abbreviationToUnitMap[lowerCaseAbbreviation] = unitsForAbbreviation = new List<int>();
 
  abbreviationsForUnit.Remove(abbreviation);
  unitsForAbbreviation.Remove(unit);

UnitsNet/InternalHelpers/ReflectionBridgeExtensions.cs

@@ -51,6 +51,15 @@ internal static bool IsEnum(this Type type)
 #endif
  }
 
+ internal static bool IsClass(this Type type)
+ {
+#if !(NET40 || NET35 || NET20 || SILVERLIGHT)
+ return type.GetTypeInfo().IsClass;
+#else
+ return type.IsClass;
+#endif
+ }
+
  internal static bool IsValueType(this Type type)
  {
 #if !(NET40 || NET35 || NET20 || SILVERLIGHT)

UnitsNet/UnitConverter.cs

@@ -40,10 +40,18 @@ namespace UnitsNet
  /// </summary>
  public static class UnitConverter
  {
- private static readonly string QuantityNamespace = typeof(Length).Namespace;
  private static readonly string UnitTypeNamespace = typeof(LengthUnit).Namespace;
  private static readonly Assembly UnitsNetAssembly = typeof(Length).GetAssembly();
 
+ private static readonly Type[] QuantityTypes = UnitsNetAssembly.GetTypes()
+ .Where(typeof(IQuantity).IsAssignableFrom)
+ .Where(x => x.IsClass() || x.IsValueType()) // Future-proofing: we are discussing changing quantities from struct to class
+ .ToArray();
+
+ private static readonly Type[] UnitTypes = UnitsNetAssembly.GetTypes()
+ .Where(x => x.Namespace == UnitTypeNamespace && x.IsEnum() && x.Name.EndsWith("Unit"))
+ .ToArray();
+
  /// <summary>
  /// Convert between any two quantity units by their names, such as converting a "Length" of N "Meter" to "Centimeter".
  /// This is particularly useful for creating things like a generated unit conversion UI,
@@ -72,7 +80,7 @@ public static class UnitConverter
  /// <returns>Output value as the result of converting to <paramref name="toUnit" />.</returns>
  /// <exception cref="QuantityNotFoundException">No quantities were found that match <paramref name="quantityName" />.</exception>
  /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
- /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbrevation.</exception>
+ /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
  public static double ConvertByName(FromValue fromValue, string quantityName, string fromUnit, string toUnit)
  {
  if(!TryGetQuantityType(quantityName, out var quantityType))
@@ -219,7 +227,7 @@ public static double ConvertByAbbreviation(FromValue fromValue, string quantityN
  /// <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>
+ /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
  public static double ConvertByAbbreviation(FromValue fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, string culture)
  {
  if(!TryGetQuantityType(quantityName, out var quantityType))
@@ -384,37 +392,30 @@ 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.OrdinalIgnoreCase));
+ if(unitName == null)
  return false;
 
  unitValue = Enum.Parse(unitType, unitName);
- if(unitValue == null)
- return false;
-
  return true;
  }
 
  private static bool TryGetUnitType(string quantityName, out Type unitType)
  {
-string unitTypeName = $"{UnitTypeNamespace}.{quantityName}Unit";
+var unitTypeName = quantityName + "Unit"; // ex. LengthUnit
 
- unitType = UnitsNetAssembly.GetType(unitTypeName); // ex: UnitsNet.Units.LengthUnit enum
- if(unitType == null)
- return false;
+ unitType = UnitTypes.FirstOrDefault(x =>
+ x.Name.Equals(unitTypeName, StringComparison.OrdinalIgnoreCase));
 
- return true;
+ return unitType != null;
  }
 
  private static bool TryGetQuantityType(string quantityName, out Type quantityType)
  {
-string quantityTypeName = $"{QuantityNamespace}.{quantityName}";
+quantityType = QuantityTypes.FirstOrDefault(x => x.Name.Equals(quantityName, StringComparison.OrdinalIgnoreCase));
 
- quantityType = UnitsNetAssembly.GetType(quantityTypeName); // ex: UnitsNet.Length struct
- if(quantityType == null)
- return false;
-
- return true;
+ return quantityType != null;
  }
  }
 }