UnitAbbreviationsCache.CreateDefault should use the default QuantityInfoLookup (#1548)

- `UnitAbbreviationsCache`: refactored the constructors / Create factory
methods, with the Map/Get methods throwing an exception for missing
units / unmapped abbreviations
- `UnitAbbreviationsCache`: replaced the `string[]` return types with
`IReadOnlyList` (breaking change for `.Length` which now becomes
`.Count`)
- `UnitAbbreviationsCache`: removed  the overload accepting a `UnitInfo`
- `UnitParser`: optimized the unit-parsing-with-fallback-culture
methods, making the `FromUnitAbbreviation` behavior consistent with that
of `ParseUnit`
- `UnitParser`: `UnitInfo GetUnitFromAbbreviation(string
unitAbbreviation, IFormatProvider? formatProvider)` : flipped the
parameters and made the method public (_this is optional_)
- optimized the `Mass.ParseUnit` calls (avoiding the `UnitInfo` lookups)
- completed the coverage of the `UnitParser` and
`UnitAbbreviationsCache`

fixes #1509

Author: lipchev

CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs

@@ -565,7 +565,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? pro
         /// <exception cref=""UnitsNetException"">Error parsing string.</exception>
         public static {_unitEnumName} ParseUnit(string str, IFormatProvider? provider)
         {{
-            return UnitsNetSetup.Default.UnitParser.Parse<{_unitEnumName}>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }}
 
         /// <inheritdoc cref=""TryParseUnit(string,IFormatProvider,out UnitsNet.Units.{_unitEnumName})""/>
@@ -586,7 +586,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out {_unitEnumNa
         /// <param name=""provider"">Format to use when parsing number and unit. Defaults to <see cref=""CultureInfo.CurrentCulture"" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out {_unitEnumName} unit)
         {{
-            return UnitsNetSetup.Default.UnitParser.TryParse<{_unitEnumName}>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }}
 
         #endregion

UnitsNet.Benchmark/Initializations/UnitAbbreviationsCacheInitializationBenchmarks.cs

@@ -47,25 +47,4 @@ public string WithSpecificQuantityAndCustomMapping()
         cache.MapUnitToDefaultAbbreviation(MassUnit.Gram, "zz");
         return cache.GetDefaultAbbreviation(MassUnit.Gram);
     }
-
-    [Benchmark]
-    public string DefaultWithoutLookup()
-    {
-        var cache = UnitAbbreviationsCache.CreateDefault();
-        return cache.GetAbbreviations(Mass.Info.BaseUnitInfo)[0];
-    }
-
-    [Benchmark]
-    public string EmptyWithoutLookup()
-    {
-        var cache = new UnitAbbreviationsCache();
-        return cache.GetAbbreviations(Mass.Info.BaseUnitInfo)[0];
-    }
-
-    [Benchmark]
-    public string WithSpecificQuantityWithoutLookup()
-    {
-        var cache = new UnitAbbreviationsCache([Mass.Info]);
-        return cache.GetAbbreviations(Mass.Info.BaseUnitInfo)[0];
-    }
 }

UnitsNet.Tests/CustomQuantities/HowMuch.cs

@@ -27,7 +27,7 @@ public HowMuch(double value, HowMuchUnit unit)
 
         public BaseDimensions Dimensions => BaseDimensions.Dimensionless;
 
-        public QuantityInfo QuantityInfo => new(
+        public static QuantityInfo Info = new(
             nameof(HowMuch),
             typeof(HowMuchUnit),
             new UnitInfo[]
@@ -40,6 +40,11 @@ public HowMuch(double value, HowMuchUnit unit)
             Zero,
             BaseDimensions.Dimensionless);
 
+        QuantityInfo IQuantity.QuantityInfo
+        {
+            get { return Info; }
+        }
+
         public double As(Enum unit) => Convert.ToDouble(unit);
 
         public double As(UnitSystem unitSystem) => throw new NotImplementedException();

UnitsNet.Tests/QuantityParserTests.cs

@@ -13,13 +13,13 @@ public class QuantityParserTests
         [Fact]
         public void Parse_WithSingleCaseInsensitiveMatch_ParsesWithMatchedUnit()
         {
-            var unitAbbreviationsCache = new UnitAbbreviationsCache();
+            var unitAbbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
             unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.Some, "foo");
             var quantityParser = new QuantityParser(unitAbbreviationsCache);
 
             HowMuch q = quantityParser.Parse<HowMuch, HowMuchUnit>("1 FOO",
                 null,
-                (value, unit) => new HowMuch((double) value, unit));
+                (value, unit) => new HowMuch(value, unit));
 
             Assert.Equal(HowMuchUnit.Some, q.Unit);
             Assert.Equal(1, q.Value);
@@ -28,14 +28,14 @@ public void Parse_WithSingleCaseInsensitiveMatch_ParsesWithMatchedUnit()
         [Fact]
         public void Parse_WithOneCaseInsensitiveMatchAndOneExactMatch_ParsesWithTheExactMatchUnit()
         {
-            var unitAbbreviationsCache = new UnitAbbreviationsCache();
+            var unitAbbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
             unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.Some, "foo");
             unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.ATon, "FOO");
             var quantityParser = new QuantityParser(unitAbbreviationsCache);
 
             HowMuch q = quantityParser.Parse<HowMuch, HowMuchUnit>("1 FOO",
                 null,
-                (value, unit) => new HowMuch((double) value, unit));
+                (value, unit) => new HowMuch(value, unit));
 
             Assert.Equal(HowMuchUnit.ATon, q.Unit);
             Assert.Equal(1, q.Value);
@@ -44,14 +44,14 @@ public void Parse_WithOneCaseInsensitiveMatchAndOneExactMatch_ParsesWithTheExact
         [Fact]
         public void Parse_WithMultipleCaseInsensitiveMatchesButNoExactMatches_ThrowsAmbiguousUnitParseException()
         {
-            var unitAbbreviationsCache = new UnitAbbreviationsCache();
+            var unitAbbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
             unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.Some, "foo");
             unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.ATon, "FOO");
             var quantityParser = new QuantityParser(unitAbbreviationsCache);
 
             void Act()
             {
-                quantityParser.Parse<HowMuch, HowMuchUnit>("1 Foo", null, (value, unit) => new HowMuch((double) value, unit));
+                quantityParser.Parse<HowMuch, HowMuchUnit>("1 Foo", null, (value, unit) => new HowMuch(value, unit));
             }
 
             var ex = Assert.Throws<AmbiguousUnitParseException>(Act);
@@ -61,13 +61,13 @@ void Act()
         [Fact]
         public void Parse_MappedCustomUnit()
         {
-            var unitAbbreviationsCache = new UnitAbbreviationsCache();
+            var unitAbbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
             unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.Some, "fooh");
             var quantityParser = new QuantityParser(unitAbbreviationsCache);
 
             HowMuch q = quantityParser.Parse<HowMuch, HowMuchUnit>("1 fooh",
                 null,
-                (value, unit) => new HowMuch((double) value, unit));
+                (value, unit) => new HowMuch(value, unit));
 
             Assert.Equal(HowMuchUnit.Some, q.Unit);
             Assert.Equal(1, q.Value);
@@ -76,13 +76,13 @@ public void Parse_MappedCustomUnit()
         [Fact]
         public void TryParse_MappedCustomUnit()
         {
-            var unitAbbreviationsCache = new UnitAbbreviationsCache();
+            var unitAbbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
             unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.Some, "fooh");
             var quantityParser = new QuantityParser(unitAbbreviationsCache);
 
             bool success = quantityParser.TryParse<HowMuch, HowMuchUnit>("1 fooh",
                 null,
-                (value, unit) => new HowMuch((double) value, unit),
+                (value, unit) => new HowMuch(value, unit),
                 out HowMuch q);
 
             Assert.True(success);

UnitsNet.Tests/QuantityTests.cs

@@ -174,21 +174,23 @@ public void FromUnitAbbreviation_MatchingCulture_ReturnsQuantity()
         }
 
         [Fact]
-        public void TryFromUnitAbbreviation_MatchingCulture_ReturnsQuantity()
+        public void FromUnitAbbreviation_MatchingFallbackCulture_ReturnsQuantity()
         {
-            Assert.False(Quantity.TryFromUnitAbbreviation(Russian, 5, "cm", out IQuantity? q));
+            // The localized abbreviation is "см"
+            IQuantity quantity = Quantity.FromUnitAbbreviation(Russian, 5, "cm");  
+            Assert.Equal(5, quantity.Value);
+            Assert.Equal(LengthUnit.Centimeter, quantity.Unit);
         }
 
         [Fact]
-        public void FromUnitAbbreviation_MismatchingCulture_ThrowsUnitNotFoundException()
+        public void TryFromUnitAbbreviation_MatchingFallbackCulture_ReturnsQuantity()
         {
-            Assert.Throws<UnitNotFoundException>(() => Quantity.FromUnitAbbreviation(Russian, 5, "cm")); // Expected "см"
-        }
-
-        [Fact]
-        public void TryFromUnitAbbreviation_MismatchingCulture_ThrowsUnitNotFoundException()
-        {
-            Assert.Throws<UnitNotFoundException>(() => Quantity.FromUnitAbbreviation(Russian, 5, "cm")); // Expected "см"
+            // The localized abbreviation is "см"
+            var success = Quantity.TryFromUnitAbbreviation(Russian, 5, "cm", out IQuantity? quantity);
+            Assert.True(success); 
+            Assert.NotNull(quantity);  
+            Assert.Equal(5, quantity.Value);
+            Assert.Equal(LengthUnit.Centimeter, quantity.Unit);
         }
 
         [Fact]