From 1d88908cdbf8040acd56e6d21008ab44a5992541 Mon Sep 17 00:00:00 2001
From: lipchev <lipchev@gmail.com>
Date: Fri, 18 Apr 2025 14:07:34 +0300
Subject: [PATCH 1/3] - `UnitAbbreviationsCache`: refactored the constructors /
 Create factory methods, with the Map/Get now throwing an exception for
 missing units / unmapped abbreviations - `UnitParser`: optimized the
 unit-parsing-with-fallback-culture methods, making the `FromUnitAbbreviation`
 behavior consistent with that of `ParseUnit` - optimzed the  `Mass.ParseUnit`
 calls (avoiding the `UnitInfo` lookups)

---
 .../UnitsNetGen/QuantityGenerator.cs          |   4 +-
 ...reviationsCacheInitializationBenchmarks.cs |   6 +-
 UnitsNet.Tests/CustomQuantities/HowMuch.cs    |   7 +-
 UnitsNet.Tests/QuantityParserTests.cs         |  20 +-
 UnitsNet.Tests/QuantityTests.cs               |  22 +-
 UnitsNet.Tests/UnitAbbreviationsCacheTests.cs |  25 +-
 UnitsNet.Tests/UnitParserTests.cs             |   2 +-
 UnitsNet/CustomCode/UnitAbbreviationsCache.cs | 432 +++++-----
 UnitsNet/CustomCode/UnitParser.cs             | 774 ++++++++++++------
 .../AbsorbedDoseOfIonizingRadiation.g.cs      |   4 +-
 .../Quantities/Acceleration.g.cs              |   4 +-
 .../Quantities/AmountOfSubstance.g.cs         |   4 +-
 .../Quantities/AmplitudeRatio.g.cs            |   4 +-
 UnitsNet/GeneratedCode/Quantities/Angle.g.cs  |   4 +-
 UnitsNet/GeneratedCode/Quantities/Area.g.cs   |   4 +-
 .../GeneratedCode/Quantities/AreaDensity.g.cs |   4 +-
 .../Quantities/AreaMomentOfInertia.g.cs       |   4 +-
 .../GeneratedCode/Quantities/BitRate.g.cs     |   4 +-
 .../BrakeSpecificFuelConsumption.g.cs         |   4 +-
 .../CoefficientOfThermalExpansion.g.cs        |   4 +-
 .../Quantities/Compressibility.g.cs           |   4 +-
 .../GeneratedCode/Quantities/Density.g.cs     |   4 +-
 .../Quantities/DoseAreaProduct.g.cs           |   4 +-
 .../GeneratedCode/Quantities/Duration.g.cs    |   4 +-
 .../Quantities/DynamicViscosity.g.cs          |   4 +-
 .../Quantities/ElectricAdmittance.g.cs        |   4 +-
 .../Quantities/ElectricApparentEnergy.g.cs    |   4 +-
 .../Quantities/ElectricApparentPower.g.cs     |   4 +-
 .../Quantities/ElectricCapacitance.g.cs       |   4 +-
 .../Quantities/ElectricCharge.g.cs            |   4 +-
 .../Quantities/ElectricChargeDensity.g.cs     |   4 +-
 .../Quantities/ElectricConductance.g.cs       |   4 +-
 .../Quantities/ElectricConductivity.g.cs      |   4 +-
 .../Quantities/ElectricCurrent.g.cs           |   4 +-
 .../Quantities/ElectricCurrentDensity.g.cs    |   4 +-
 .../Quantities/ElectricCurrentGradient.g.cs   |   4 +-
 .../Quantities/ElectricField.g.cs             |   4 +-
 .../Quantities/ElectricImpedance.g.cs         |   4 +-
 .../Quantities/ElectricInductance.g.cs        |   4 +-
 .../Quantities/ElectricPotential.g.cs         |   4 +-
 .../ElectricPotentialChangeRate.g.cs          |   4 +-
 .../Quantities/ElectricReactance.g.cs         |   4 +-
 .../Quantities/ElectricReactiveEnergy.g.cs    |   4 +-
 .../Quantities/ElectricReactivePower.g.cs     |   4 +-
 .../Quantities/ElectricResistance.g.cs        |   4 +-
 .../Quantities/ElectricResistivity.g.cs       |   4 +-
 .../ElectricSurfaceChargeDensity.g.cs         |   4 +-
 .../Quantities/ElectricSusceptance.g.cs       |   4 +-
 UnitsNet/GeneratedCode/Quantities/Energy.g.cs |   4 +-
 .../Quantities/EnergyDensity.g.cs             |   4 +-
 .../GeneratedCode/Quantities/Entropy.g.cs     |   4 +-
 .../Quantities/FluidResistance.g.cs           |   4 +-
 UnitsNet/GeneratedCode/Quantities/Force.g.cs  |   4 +-
 .../Quantities/ForceChangeRate.g.cs           |   4 +-
 .../Quantities/ForcePerLength.g.cs            |   4 +-
 .../GeneratedCode/Quantities/Frequency.g.cs   |   4 +-
 .../Quantities/FuelEfficiency.g.cs            |   4 +-
 .../GeneratedCode/Quantities/HeatFlux.g.cs    |   4 +-
 .../Quantities/HeatTransferCoefficient.g.cs   |   4 +-
 .../GeneratedCode/Quantities/Illuminance.g.cs |   4 +-
 .../GeneratedCode/Quantities/Impulse.g.cs     |   4 +-
 .../GeneratedCode/Quantities/Information.g.cs |   4 +-
 .../GeneratedCode/Quantities/Irradiance.g.cs  |   4 +-
 .../GeneratedCode/Quantities/Irradiation.g.cs |   4 +-
 UnitsNet/GeneratedCode/Quantities/Jerk.g.cs   |   4 +-
 .../Quantities/KinematicViscosity.g.cs        |   4 +-
 .../GeneratedCode/Quantities/LeakRate.g.cs    |   4 +-
 UnitsNet/GeneratedCode/Quantities/Length.g.cs |   4 +-
 UnitsNet/GeneratedCode/Quantities/Level.g.cs  |   4 +-
 .../Quantities/LinearDensity.g.cs             |   4 +-
 .../Quantities/LinearPowerDensity.g.cs        |   4 +-
 .../GeneratedCode/Quantities/Luminance.g.cs   |   4 +-
 .../GeneratedCode/Quantities/Luminosity.g.cs  |   4 +-
 .../Quantities/LuminousFlux.g.cs              |   4 +-
 .../Quantities/LuminousIntensity.g.cs         |   4 +-
 .../Quantities/MagneticField.g.cs             |   4 +-
 .../Quantities/MagneticFlux.g.cs              |   4 +-
 .../Quantities/Magnetization.g.cs             |   4 +-
 UnitsNet/GeneratedCode/Quantities/Mass.g.cs   |   4 +-
 .../Quantities/MassConcentration.g.cs         |   4 +-
 .../GeneratedCode/Quantities/MassFlow.g.cs    |   4 +-
 .../GeneratedCode/Quantities/MassFlux.g.cs    |   4 +-
 .../Quantities/MassFraction.g.cs              |   4 +-
 .../Quantities/MassMomentOfInertia.g.cs       |   4 +-
 .../GeneratedCode/Quantities/Molality.g.cs    |   4 +-
 .../GeneratedCode/Quantities/MolarEnergy.g.cs |   4 +-
 .../Quantities/MolarEntropy.g.cs              |   4 +-
 .../GeneratedCode/Quantities/MolarFlow.g.cs   |   4 +-
 .../GeneratedCode/Quantities/MolarMass.g.cs   |   4 +-
 .../GeneratedCode/Quantities/Molarity.g.cs    |   4 +-
 .../Quantities/Permeability.g.cs              |   4 +-
 .../Quantities/Permittivity.g.cs              |   4 +-
 .../Quantities/PorousMediumPermeability.g.cs  |   4 +-
 UnitsNet/GeneratedCode/Quantities/Power.g.cs  |   4 +-
 .../Quantities/PowerDensity.g.cs              |   4 +-
 .../GeneratedCode/Quantities/PowerRatio.g.cs  |   4 +-
 .../GeneratedCode/Quantities/Pressure.g.cs    |   4 +-
 .../Quantities/PressureChangeRate.g.cs        |   4 +-
 .../Quantities/RadiationEquivalentDose.g.cs   |   4 +-
 .../RadiationEquivalentDoseRate.g.cs          |   4 +-
 .../Quantities/RadiationExposure.g.cs         |   4 +-
 .../Quantities/Radioactivity.g.cs             |   4 +-
 UnitsNet/GeneratedCode/Quantities/Ratio.g.cs  |   4 +-
 .../Quantities/RatioChangeRate.g.cs           |   4 +-
 .../Quantities/ReciprocalArea.g.cs            |   4 +-
 .../Quantities/ReciprocalLength.g.cs          |   4 +-
 .../Quantities/RelativeHumidity.g.cs          |   4 +-
 .../Quantities/RotationalAcceleration.g.cs    |   4 +-
 .../Quantities/RotationalSpeed.g.cs           |   4 +-
 .../Quantities/RotationalStiffness.g.cs       |   4 +-
 .../RotationalStiffnessPerLength.g.cs         |   4 +-
 UnitsNet/GeneratedCode/Quantities/Scalar.g.cs |   4 +-
 .../GeneratedCode/Quantities/SolidAngle.g.cs  |   4 +-
 .../Quantities/SpecificEnergy.g.cs            |   4 +-
 .../Quantities/SpecificEntropy.g.cs           |   4 +-
 .../Quantities/SpecificFuelConsumption.g.cs   |   4 +-
 .../Quantities/SpecificVolume.g.cs            |   4 +-
 .../Quantities/SpecificWeight.g.cs            |   4 +-
 UnitsNet/GeneratedCode/Quantities/Speed.g.cs  |   4 +-
 .../Quantities/StandardVolumeFlow.g.cs        |   4 +-
 .../GeneratedCode/Quantities/Temperature.g.cs |   4 +-
 .../Quantities/TemperatureChangeRate.g.cs     |   4 +-
 .../Quantities/TemperatureDelta.g.cs          |   4 +-
 .../Quantities/TemperatureGradient.g.cs       |   4 +-
 .../Quantities/ThermalConductivity.g.cs       |   4 +-
 .../Quantities/ThermalInsulance.g.cs          |   4 +-
 UnitsNet/GeneratedCode/Quantities/Torque.g.cs |   4 +-
 .../GeneratedCode/Quantities/Turbidity.g.cs   |   4 +-
 .../GeneratedCode/Quantities/VitaminA.g.cs    |   4 +-
 UnitsNet/GeneratedCode/Quantities/Volume.g.cs |   4 +-
 .../Quantities/VolumeConcentration.g.cs       |   4 +-
 .../GeneratedCode/Quantities/VolumeFlow.g.cs  |   4 +-
 .../Quantities/VolumeFlowPerArea.g.cs         |   4 +-
 .../Quantities/VolumePerLength.g.cs           |   4 +-
 .../Quantities/VolumetricHeatCapacity.g.cs    |   4 +-
 .../Quantities/WarpingMomentOfInertia.g.cs    |   4 +-
 136 files changed, 1082 insertions(+), 718 deletions(-)

diff --git a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
index 63cab0add0..a3be4f0208 100644
--- a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
+++ b/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
diff --git a/UnitsNet.Benchmark/Initializations/UnitAbbreviationsCacheInitializationBenchmarks.cs b/UnitsNet.Benchmark/Initializations/UnitAbbreviationsCacheInitializationBenchmarks.cs
index 26e6d9722b..8dd93340eb 100644
--- a/UnitsNet.Benchmark/Initializations/UnitAbbreviationsCacheInitializationBenchmarks.cs
+++ b/UnitsNet.Benchmark/Initializations/UnitAbbreviationsCacheInitializationBenchmarks.cs
@@ -52,20 +52,20 @@ public string WithSpecificQuantityAndCustomMapping()
     public string DefaultWithoutLookup()
     {
         var cache = UnitAbbreviationsCache.CreateDefault();
-        return cache.GetAbbreviations(Mass.Info.BaseUnitInfo)[0];
+        return Mass.GetAbbreviation(Mass.BaseUnit);
     }
 
     [Benchmark]
     public string EmptyWithoutLookup()
     {
         var cache = new UnitAbbreviationsCache();
-        return cache.GetAbbreviations(Mass.Info.BaseUnitInfo)[0];
+        return Mass.GetAbbreviation(Mass.BaseUnit);
     }
 
     [Benchmark]
     public string WithSpecificQuantityWithoutLookup()
     {
         var cache = new UnitAbbreviationsCache([Mass.Info]);
-        return cache.GetAbbreviations(Mass.Info.BaseUnitInfo)[0];
+        return Mass.GetAbbreviation(Mass.BaseUnit);
     }
 }
diff --git a/UnitsNet.Tests/CustomQuantities/HowMuch.cs b/UnitsNet.Tests/CustomQuantities/HowMuch.cs
index 233c97b1f1..233c2490ef 100644
--- a/UnitsNet.Tests/CustomQuantities/HowMuch.cs
+++ b/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();
diff --git a/UnitsNet.Tests/QuantityParserTests.cs b/UnitsNet.Tests/QuantityParserTests.cs
index b56fa10d90..e63f29fdb7 100644
--- a/UnitsNet.Tests/QuantityParserTests.cs
+++ b/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);
diff --git a/UnitsNet.Tests/QuantityTests.cs b/UnitsNet.Tests/QuantityTests.cs
index 22154965fb..e50a25ba23 100644
--- a/UnitsNet.Tests/QuantityTests.cs
+++ b/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]
diff --git a/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs b/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs
index 2d565419c4..41ccea2340 100644
--- a/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs
+++ b/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs
@@ -28,8 +28,8 @@ public void UnitAbbreviationsCacheDefaultReturnsUnitsNetSetupDefaultUnitAbbrevia
         public void GetUnitAbbreviationsThrowsUnitNotFoundExceptionIfNoneExist()
         {
             Assert.Multiple(checks: [
-                () => Assert.Throws<UnitNotFoundException>(() => new UnitAbbreviationsCache().GetUnitAbbreviations(MassUnit.Gram)),
-                () => Assert.Throws<UnitNotFoundException>(() => new UnitAbbreviationsCache().GetUnitAbbreviations(typeof(MassUnit), (int)MassUnit.Gram))
+                () => Assert.Throws<UnitNotFoundException>(() => new UnitAbbreviationsCache().GetUnitAbbreviations(HowMuchUnit.AShitTon)),
+                () => Assert.Throws<UnitNotFoundException>(() => new UnitAbbreviationsCache().GetUnitAbbreviations(typeof(HowMuchUnit), (int)HowMuchUnit.AShitTon))
             ]);
         }
 
@@ -61,7 +61,7 @@ public void GetDefaultAbbreviationFallsBackToUsEnglishCulture()
             // Zulu (South Africa)
             var zuluCulture = CultureInfo.GetCultureInfo("zu-ZA");
 
-            var abbreviationsCache = new UnitAbbreviationsCache();
+            var abbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
             abbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.AShitTon, AmericanCulture, "US english abbreviation for Unit1");
 
             // Act
@@ -75,11 +75,17 @@ public void GetDefaultAbbreviationFallsBackToUsEnglishCulture()
         public void GetDefaultAbbreviationThrowsUnitNotFoundExceptionIfNoneExist()
         {
             Assert.Multiple(checks: [
-                () => Assert.Throws<UnitNotFoundException>(() => new UnitAbbreviationsCache().GetDefaultAbbreviation(MassUnit.Gram)),
-                () => Assert.Throws<UnitNotFoundException>(() => new UnitAbbreviationsCache().GetDefaultAbbreviation(typeof(MassUnit), (int)MassUnit.Gram))
+                () => Assert.Throws<UnitNotFoundException>(() => new UnitAbbreviationsCache().GetDefaultAbbreviation(HowMuchUnit.AShitTon)),
+                () => Assert.Throws<UnitNotFoundException>(() => new UnitAbbreviationsCache().GetDefaultAbbreviation(typeof(HowMuchUnit), (int)HowMuchUnit.AShitTon))
             ]);
         }
 
+        [Fact]
+        public void GetDefaultAbbreviation_ForUnitWithoutAbbreviations_ThrowsInvalidOperationException()
+        {
+            Assert.Throws<InvalidOperationException>(() => new UnitAbbreviationsCache([HowMuch.Info]).GetDefaultAbbreviation(HowMuchUnit.AShitTon));
+        }
+
         [Fact]
         public void GetAbbreviationsThrowsArgumentNullExceptionWhenGivenANullUnitInfo()
         {
@@ -172,7 +178,7 @@ public void MapUnitToAbbreviation_GivenUnitTypeAndValue_AddsTheAbbreviationForUn
         [Fact]
         public void MapUnitToAbbreviation_DoesNotInsertDuplicates()
         {
-            var cache = new UnitAbbreviationsCache();
+            var cache = new UnitAbbreviationsCache([HowMuch.Info]);
 
             cache.MapUnitToAbbreviation(HowMuchUnit.Some, "sm");
             cache.MapUnitToAbbreviation(HowMuchUnit.Some, "sm");
@@ -186,7 +192,7 @@ public void MapUnitToAbbreviation_DoesNotInsertDuplicates()
         [Fact]
         public void MapUnitToDefaultAbbreviation_Twice_SetsNewDefaultAndKeepsOrderOfExistingAbbreviations()
         {
-            var cache = new UnitAbbreviationsCache();
+            var cache = new UnitAbbreviationsCache([HowMuch.Info]);
 
             cache.MapUnitToAbbreviation(HowMuchUnit.Some, "sm");
             cache.MapUnitToDefaultAbbreviation(HowMuchUnit.Some, "1st default");
@@ -204,8 +210,9 @@ public void MapUnitToDefaultAbbreviation_Twice_SetsNewDefaultAndKeepsOrderOfExis
         [Fact]
         public void MapAndLookup_WithSpecificEnumType()
         {
-            UnitsNetSetup.Default.UnitAbbreviations.MapUnitToDefaultAbbreviation(HowMuchUnit.Some, "sm");
-            Assert.Equal("sm", UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(HowMuchUnit.Some));
+            var unitAbbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
+            unitAbbreviationsCache.MapUnitToDefaultAbbreviation(HowMuchUnit.Some, "sm");
+            Assert.Equal("sm", unitAbbreviationsCache.GetDefaultAbbreviation(HowMuchUnit.Some));
         }
     }
 }
diff --git a/UnitsNet.Tests/UnitParserTests.cs b/UnitsNet.Tests/UnitParserTests.cs
index 17b2007e40..fc1edf2df9 100644
--- a/UnitsNet.Tests/UnitParserTests.cs
+++ b/UnitsNet.Tests/UnitParserTests.cs
@@ -135,7 +135,7 @@ public void ParseMassUnit_GivenCulture(string str, string cultureName, Enum expe
         [Fact]
         public void Parse_MappedCustomUnit()
         {
-            var unitAbbreviationsCache = new UnitAbbreviationsCache();
+            var unitAbbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
             unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.Some, "fooh");
             var unitParser = new UnitParser(unitAbbreviationsCache);
 
diff --git a/UnitsNet/CustomCode/UnitAbbreviationsCache.cs b/UnitsNet/CustomCode/UnitAbbreviationsCache.cs
index 264caa0d93..812c3eccce 100644
--- a/UnitsNet/CustomCode/UnitAbbreviationsCache.cs
+++ b/UnitsNet/CustomCode/UnitAbbreviationsCache.cs
@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Reflection;
 using System.Resources;
 using UnitsNet.Units;
 using AbbreviationMapKey = System.ValueTuple<UnitsNet.UnitKey, string>;
@@ -15,32 +16,35 @@ namespace UnitsNet
 {
     /// <summary>
     ///     Cache of the mapping between unit enum values and unit abbreviation strings for one or more cultures.
-    ///     A static instance <see cref="UnitsNetSetup"/>.<see cref="UnitsNetSetup.Default"/>.<see cref="UnitsNetSetup.UnitAbbreviations"/> is used internally
-    ///     for ToString() and Parse() of quantities and units.
+    ///     A static instance is created in the <see cref="UnitsNetSetup.Default"/>, which is used for ToString() and Parse() of quantities and units.
     /// </summary>
     public sealed class UnitAbbreviationsCache
     {
         /// <summary>
-        ///     Fallback culture used by <see cref="GetUnitAbbreviations{TUnitType}" /> and <see cref="GetDefaultAbbreviation{TUnitType}" />
+        ///     Fallback culture used by <see cref="GetUnitAbbreviations(UnitKey,IFormatProvider?)" /> and <see cref="GetDefaultAbbreviation(UnitKey,IFormatProvider?)" />
         ///     if no abbreviations are found with a given culture.
         /// </summary>
         /// <example>
-        ///     User wants to call <see cref="UnitParser.Parse{TUnitType}" /> or <see cref="Length.ToString()" /> with Russian
-        ///     culture, but no translation is defined, so we return the US English definition as a last resort. If it's not
+        ///     User wants to call <see cref="UnitParser.Parse{TUnitType}(string,IFormatProvider?)" /> or <see cref="Length.ToString()" /> with Russian
+        ///     culture, but no translation is defined, so we return the US English (en-US)  definition as a last resort. If it's not
         ///     defined there either, an exception is thrown.
         /// </example>
         internal static readonly CultureInfo FallbackCulture = CultureInfo.InvariantCulture;
 
         /// <summary>
-        ///     The default singleton instance with the default configured unit abbreviations, used for ToString() and parsing of quantities and units.
+        ///     The static instance used internally for ToString() and Parse() of quantities and units.
         /// </summary>
-        /// <remarks>
-        ///     Convenience shortcut for <see cref="UnitsNetSetup"/>.<see cref="UnitsNetSetup.Default"/>.<see cref="UnitsNetSetup.UnitAbbreviations"/>.<br />
-        ///     You can add custom unit abbreviations at runtime, and this will affect all usages globally in the application.
-        /// </remarks>
         public static UnitAbbreviationsCache Default => UnitsNetSetup.Default.UnitAbbreviations;
 
-        private QuantityInfoLookup QuantityInfoLookup { get; }
+        /// <summary>
+        ///     Gets the lookup table for quantity information used by this cache.
+        /// </summary>
+        /// <remarks>
+        ///     This property provides access to the <see cref="QuantityInfoLookup" /> instance that contains
+        ///     information about quantities and their associated units. It is used internally to map units
+        ///     to their abbreviations and vice versa.
+        /// </remarks>
+        internal QuantityInfoLookup Quantities { get; }
 
         /// <summary>
         /// Culture name to abbreviations. To add a custom default abbreviation, add to the beginning of the list.
@@ -48,10 +52,11 @@ public sealed class UnitAbbreviationsCache
         private ConcurrentDictionary<AbbreviationMapKey, IReadOnlyList<string>> AbbreviationsMap { get; } = new();
 
         /// <summary>
-        ///     Create an empty instance of the cache, with no default abbreviations loaded.
+        ///      Create an instance of the cache and load all the built-in quantities defined in the library.
         /// </summary>
+        /// <returns>Instance for mapping any of the built-in units.</returns>
         public UnitAbbreviationsCache()
-            : this(new QuantityInfoLookup([]))
+            :this(UnitsNetSetup.Default.QuantityInfoLookup)
         {
         }
         
@@ -63,116 +68,146 @@ public UnitAbbreviationsCache(IEnumerable<QuantityInfo> quantities)
             :this(new QuantityInfoLookup(quantities))
         {
         }
-        
+
         /// <summary>
         ///     Creates an instance of the cache using the specified set of quantities.
         /// </summary>
         /// <remarks>
         ///     Access type is <c>internal</c> until this class is matured and ready for external use.
         /// </remarks>
-        internal UnitAbbreviationsCache(QuantityInfoLookup quantityInfoLookup)
+        internal UnitAbbreviationsCache(QuantityInfoLookup quantities)
         {
-            QuantityInfoLookup = quantityInfoLookup;
+            Quantities = quantities;
         }
-        
+
         /// <summary>
         ///     Create an instance of the cache and load all the built-in quantities defined in the library.
         /// </summary>
         /// <returns>Instance for mapping any of the built-in units.</returns>
-        public static UnitAbbreviationsCache CreateDefault() => new(new QuantityInfoLookup(Quantity.Infos));
-
+        public static UnitAbbreviationsCache CreateDefault()
+        {
+            return new UnitAbbreviationsCache();
+        }
+        
+        #region MapUnitToAbbreviation overloads
+        
         /// <summary>
         /// Adds one or more unit abbreviation for the given unit enum value.
         /// This is used to dynamically add abbreviations for existing unit enums such as <see cref="UnitsNet.Units.LengthUnit"/> or to extend with third-party unit enums
-        /// in order to <see cref="UnitParser.Parse{TUnitType}"/> or <see cref="GetDefaultAbbreviation{TUnitType}"/> on them later.
+        /// in order to <see cref="UnitParser.Parse{TUnitType}(string,IFormatProvider?)"/> or <see cref="GetDefaultAbbreviation(UnitKey,IFormatProvider?)"/> on them later.
         /// </summary>
         /// <param name="unit">The unit enum value.</param>
         /// <param name="abbreviations">Unit abbreviations to add.</param>
         /// <typeparam name="TUnitType">The type of unit enum.</typeparam>
-        public void MapUnitToAbbreviation<TUnitType>(TUnitType unit, params string[] abbreviations) where TUnitType : struct, Enum
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when no unit information is found for the specified
+        ///     <paramref name="unit" />.
+        /// </exception>
+        public void MapUnitToAbbreviation<TUnitType>(TUnitType unit, params IEnumerable<string> abbreviations)
+            where TUnitType : struct, Enum
         {
-            PerformAbbreviationMapping(UnitKey.ForUnit(unit), CultureInfo.CurrentCulture, false, abbreviations);
+            MapUnitToAbbreviation(UnitKey.ForUnit(unit), abbreviations);
         }
 
-        /// <summary>
-        /// Adds a unit abbreviation for the given unit enum value and sets it as the default.
-        /// This is used to dynamically add abbreviations for existing unit enums such as <see cref="UnitsNet.Units.LengthUnit"/> or to extend with third-party unit enums
-        /// in order to <see cref="UnitParser.Parse{TUnitType}"/> or <see cref="GetDefaultAbbreviation{TUnitType}"/> on them later.
-        /// </summary>
-        /// <param name="unit">The unit enum value.</param>
-        /// <param name="abbreviation">Unit abbreviations to add as default.</param>
-        /// <typeparam name="TUnitType">The type of unit enum.</typeparam>
-        public void MapUnitToDefaultAbbreviation<TUnitType>(TUnitType unit, string abbreviation) where TUnitType : struct, Enum
+        /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>>
+        /// <param name="unitType">The unit enum type.</param>
+        /// <param name="unitValue">The unit enum value.</param>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="abbreviations">Unit abbreviations to add.</param>
+        public void MapUnitToAbbreviation(Type unitType, int unitValue, IFormatProvider? formatProvider, params IEnumerable<string> abbreviations)
         {
-            PerformAbbreviationMapping(UnitKey.ForUnit(unit), CultureInfo.CurrentCulture, true, abbreviation);
+            MapUnitToAbbreviation(new UnitKey(unitType, unitValue), formatProvider, abbreviations);
         }
 
-        /// <summary>
-        /// Adds one or more unit abbreviation for the given unit enum value.
-        /// This is used to dynamically add abbreviations for existing unit enums such as <see cref="LengthUnit"/> or to extend with third-party unit enums
-        /// in order to <see cref="UnitParser.Parse{TUnitType}"/> or <see cref="GetDefaultAbbreviation{TUnitType}"/> on them later.
-        /// </summary>
+        /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>>
+        /// <param name="unitKey">The unit key value.</param>
+        /// <param name="abbreviations">Unit abbreviations to add.</param>
+        public void MapUnitToAbbreviation(UnitKey unitKey, params IEnumerable<string> abbreviations)
+        {
+            MapUnitToAbbreviation(unitKey, CultureInfo.CurrentCulture, abbreviations);
+        }
+
+        /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>>
         /// <param name="unit">The unit enum value.</param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <param name="abbreviations">Unit abbreviations to add.</param>
         /// <typeparam name="TUnitType">The type of unit enum.</typeparam>
-        public void MapUnitToAbbreviation<TUnitType>(TUnitType unit, IFormatProvider? formatProvider, params string[] abbreviations) where TUnitType : struct, Enum
+        public void MapUnitToAbbreviation<TUnitType>(TUnitType unit, IFormatProvider? formatProvider, params IEnumerable<string> abbreviations)
+            where TUnitType : struct, Enum
         {
-            PerformAbbreviationMapping(UnitKey.ForUnit(unit), formatProvider, false, abbreviations);
+            MapUnitToAbbreviation(UnitKey.ForUnit(unit), formatProvider, abbreviations);
         }
+        
+        /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>>
+        /// <param name="unitKey">The unit key value.</param>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="abbreviations">Unit abbreviations to add.</param>
+        public void MapUnitToAbbreviation(UnitKey unitKey, IFormatProvider? formatProvider, params IEnumerable<string> abbreviations)
+        {
+            PerformAbbreviationMapping(unitKey, formatProvider, false, abbreviations);
+        }
+
+        #endregion
+
+        #region MapUnitToDefaultAbbreviation overloads
 
         /// <summary>
         /// Adds a unit abbreviation for the given unit enum value and sets it as the default.
-        /// This is used to dynamically add abbreviations for existing unit enums such as <see cref="LengthUnit"/> or to extend with third-party unit enums
-        /// in order to <see cref="UnitParser.Parse{TUnitType}"/> or <see cref="GetDefaultAbbreviation{TUnitType}"/> on them later.
+        /// This is used to dynamically add abbreviations for existing unit enums such as <see cref="UnitsNet.Units.LengthUnit"/> or to extend with third-party unit enums
+        /// in order to <see cref="UnitParser.Parse{TUnitType}(string,IFormatProvider?)"/> or <see cref="GetDefaultAbbreviation(UnitKey,IFormatProvider?)"/> on them later.
         /// </summary>
         /// <param name="unit">The unit enum value.</param>
-        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
-        /// <param name="abbreviation">Unit abbreviation to add as default.</param>
+        /// <param name="abbreviation">Unit abbreviations to add as default.</param>
         /// <typeparam name="TUnitType">The type of unit enum.</typeparam>
-        public void MapUnitToDefaultAbbreviation<TUnitType>(TUnitType unit, IFormatProvider? formatProvider, string abbreviation) where TUnitType : struct, Enum
+        public void MapUnitToDefaultAbbreviation<TUnitType>(TUnitType unit, string abbreviation)
+            where TUnitType : struct, Enum
         {
-            PerformAbbreviationMapping(UnitKey.ForUnit(unit), formatProvider, true, abbreviation);
+            MapUnitToDefaultAbbreviation(UnitKey.ForUnit(unit), abbreviation);
         }
 
-        /// <summary>
-        /// Adds one or more unit abbreviation for the given unit enum value.
-        /// This is used to dynamically add abbreviations for existing unit enums such as <see cref="LengthUnit"/> or to extend with third-party unit enums
-        /// in order to <see cref="UnitParser.Parse{TUnitType}"/> or <see cref="GetDefaultAbbreviation{TUnitType}"/> on them later.
-        /// </summary>
-        /// <param name="unitType">The unit enum type.</param>
-        /// <param name="unitValue">The unit enum value.</param>
+        /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>>
+        /// <param name="unitKey">The unit key value.</param>
+        /// <param name="abbreviation">Unit abbreviations to add as default.</param>
+        public void MapUnitToDefaultAbbreviation(UnitKey unitKey, string abbreviation)
+        {
+            MapUnitToDefaultAbbreviation(unitKey, CultureInfo.CurrentCulture, abbreviation);
+        }
+
+        /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>>
+        /// <param name="unit">The unit enum value.</param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
-        /// <param name="abbreviations">Unit abbreviations to add.</param>
-        public void MapUnitToAbbreviation(Type unitType, int unitValue, IFormatProvider? formatProvider, params string[] abbreviations)
+        /// <param name="abbreviation">Unit abbreviation to add as default.</param>
+        /// <typeparam name="TUnitType">The type of unit enum.</typeparam>
+        public void MapUnitToDefaultAbbreviation<TUnitType>(TUnitType unit, IFormatProvider? formatProvider, string abbreviation)
+            where TUnitType : struct, Enum
         {
-            PerformAbbreviationMapping(new UnitKey(unitType, unitValue), formatProvider, false, abbreviations);
+            MapUnitToDefaultAbbreviation(UnitKey.ForUnit(unit), formatProvider, abbreviation);
         }
 
-        /// <summary>
-        /// Adds a unit abbreviation for the given unit enum value and sets it as the default.
-        /// This is used to dynamically add abbreviations for existing unit enums such as <see cref="LengthUnit"/> or to extend with third-party unit enums
-        /// in order to <see cref="UnitParser.Parse{TUnitType}"/> or <see cref="GetDefaultAbbreviation{TUnitType}"/> on them later.
-        /// </summary>
+        /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>>
         /// <param name="unitType">The unit enum type.</param>
         /// <param name="unitValue">The unit enum value.</param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <param name="abbreviation">Unit abbreviation to add as default.</param>
         public void MapUnitToDefaultAbbreviation(Type unitType, int unitValue, IFormatProvider? formatProvider, string abbreviation)
         {
-            PerformAbbreviationMapping(new UnitKey(unitType, unitValue), formatProvider, true, abbreviation);
+            MapUnitToDefaultAbbreviation(new UnitKey(unitType, unitValue), formatProvider, abbreviation);
         }
 
-        private void PerformAbbreviationMapping(UnitKey unitValue, IFormatProvider? formatProvider, bool setAsDefault, params string[] abbreviations)
+        /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>>
+        /// <param name="unitKey">The unit key value.</param>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="abbreviation">Unit abbreviation to add as default.</param>
+        public void MapUnitToDefaultAbbreviation(UnitKey unitKey, IFormatProvider? formatProvider, string abbreviation)
         {
-            if(!QuantityInfoLookup.TryGetUnitInfo(unitValue, out UnitInfo? unitInfo))
-            {
-                // TODO we should throw QuantityNotFoundException here (all QuantityInfos should be provided through the constructor)
-                unitInfo = new UnitInfo((Enum)unitValue, unitValue.ToString(), BaseUnits.Undefined);
-                QuantityInfoLookup.AddUnitInfo(unitInfo);
-            }
+            PerformAbbreviationMapping(unitKey, formatProvider, true, abbreviation);
+        }
+
+        #endregion
 
-            AddAbbreviation(unitInfo, formatProvider, setAsDefault, abbreviations);
+        private void PerformAbbreviationMapping(UnitKey unitKey, IFormatProvider? formatProvider, bool setAsDefault, params IEnumerable<string> abbreviations)
+        {
+            AddAbbreviation(Quantities.GetUnitInfo(unitKey), formatProvider, setAsDefault, abbreviations);
         }
         
         /// <summary>
@@ -183,7 +218,16 @@ private void PerformAbbreviationMapping(UnitKey unitValue, IFormatProvider? form
         /// <param name="unit">The unit enum value.</param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <typeparam name="TUnitType">The type of unit enum.</typeparam>
-        public string GetDefaultAbbreviation<TUnitType>(TUnitType unit, IFormatProvider? formatProvider = null) where TUnitType : struct, Enum
+        /// <returns>The default unit abbreviation string.</returns>
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when no unit information is found for the specified
+        ///     <paramref name="unit" />.
+        /// </exception>
+        /// <exception cref="InvalidOperationException">
+        ///     Thrown when no abbreviations are mapped for the specified unit.
+        /// </exception>
+        public string GetDefaultAbbreviation<TUnitType>(TUnitType unit, IFormatProvider? formatProvider = null)
+            where TUnitType : struct, Enum
         {
             return GetDefaultAbbreviation(UnitKey.ForUnit(unit), formatProvider);
         }
@@ -196,18 +240,28 @@ public string GetDefaultAbbreviation<TUnitType>(TUnitType unit, IFormatProvider?
         /// <param name="unitType">The unit enum type.</param>
         /// <param name="unitValue">The unit enum value.</param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when no unit information is found for the specified
+        ///     <paramref name="unitType" /> and <paramref name="unitValue" />.
+        /// </exception>
+        /// <exception cref="InvalidOperationException">
+        ///     Thrown when no abbreviations are mapped for the specified unit.
+        /// </exception>
         public string GetDefaultAbbreviation(Type unitType, int unitValue, IFormatProvider? formatProvider = null)
         {
             return GetDefaultAbbreviation(new UnitKey(unitType, unitValue), formatProvider);
         }
-        
-        /// <inheritdoc cref="GetDefaultAbbreviation{TUnitType}"/>
+
+        /// <inheritdoc cref="GetDefaultAbbreviation{TUnitType}" />
         /// <param name="unitKey">The key representing the unit type and value.</param>
-        /// <param name="formatProvider">
-        ///     The format provider to use for lookup. Defaults to
-        ///     <see cref="CultureInfo.CurrentCulture" /> if null.
-        /// </param>
-        /// <returns>The default unit abbreviation string.</returns>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when no unit information is found for the specified
+        ///     <paramref name="unitKey" />.
+        /// </exception>
+        /// <exception cref="InvalidOperationException">
+        ///     Thrown when no abbreviations are mapped for the specified unit.
+        /// </exception>
         public string GetDefaultAbbreviation(UnitKey unitKey, IFormatProvider? formatProvider = null)
         {
             IReadOnlyList<string> abbreviations = GetUnitAbbreviations(unitKey, formatProvider);
@@ -226,9 +280,13 @@ public string GetDefaultAbbreviation(UnitKey unitKey, IFormatProvider? formatPro
         /// <param name="unit">Enum value for unit.</param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <returns>Unit abbreviations associated with unit.</returns>
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when no unit information is found for the specified
+        ///     <paramref name="unit" />.
+        /// </exception>
         public string[] GetUnitAbbreviations<TUnitType>(TUnitType unit, IFormatProvider? formatProvider = null) where TUnitType : struct, Enum
         {
-            return GetUnitAbbreviations(UnitKey.ForUnit(unit), formatProvider).ToArray();  // TODO can we change this to return an IReadonlyCollection (as the GetAbbreviations)?
+            return GetUnitAbbreviations(UnitKey.ForUnit(unit), formatProvider).ToArray(); // TODO can we change this to return an IReadOnlyList (as the GetAbbreviations)?
         }
 
         /// <summary>
@@ -238,6 +296,10 @@ public string[] GetUnitAbbreviations<TUnitType>(TUnitType unit, IFormatProvider?
         /// <param name="unitValue">Enum value for unit.</param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <returns>Unit abbreviations associated with unit.</returns>
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when no unit information is found for the specified
+        ///     <paramref name="unitType" /> and <paramref name="unitValue" />.
+        /// </exception>
         public string[] GetUnitAbbreviations(Type unitType, int unitValue, IFormatProvider? formatProvider = null)
         {
             return GetUnitAbbreviations(new UnitKey(unitType, unitValue), formatProvider).ToArray(); // TODO can we change this to return an IReadOnlyList (as the GetAbbreviations)?
@@ -247,128 +309,147 @@ public string[] GetUnitAbbreviations(Type unitType, int unitValue, IFormatProvid
         /// Retrieves the unit abbreviations for a specified unit key and optional format provider.
         /// </summary>
         /// <param name="unitKey">The key representing the unit type and value.</param> 
-        /// <param name="formatProvider">An optional format provider to use for culture-specific formatting.</param>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <returns>A read-only collection of unit abbreviation strings.</returns>
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when no unit information is found for the specified
+        ///     <paramref name="unitKey" />.
+        /// </exception>
         public IReadOnlyList<string> GetUnitAbbreviations(UnitKey unitKey, IFormatProvider? formatProvider = null)
         {
-            return GetAbbreviations(QuantityInfoLookup.GetUnitInfo(unitKey), formatProvider);
-        }
-
-        /// <summary>
-        ///     Get all abbreviations for unit.
-        /// </summary>
-        /// <param name="unitKey">The unit-enum type as a hash-friendly type.</param>
-        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
-        /// <param name="abbreviations">The unit abbreviations associated with unit.</param>
-        /// <returns>True if found, otherwise false.</returns>
-        private bool TryGetUnitAbbreviations(UnitKey unitKey, IFormatProvider? formatProvider, out IReadOnlyList<string> abbreviations)
-        {
-            if(QuantityInfoLookup.TryGetUnitInfo(unitKey, out UnitInfo? unitInfo))
+            if (formatProvider is not CultureInfo culture)
             {
-                abbreviations = GetAbbreviations(unitInfo, formatProvider);
-                return true;
+                culture = CultureInfo.CurrentCulture;
             }
 
-            abbreviations = [];
-            return false;
+            return GetAbbreviationsWithFallbackCulture(Quantities.GetUnitInfo(unitKey), culture);
         }
 
         /// <summary>
-        ///     Get all abbreviations for all units of a quantity.
+        ///     Retrieves all abbreviations for all units of a specified quantity.
         /// </summary>
-        /// <param name="unitEnumType">Enum type for unit.</param>
+        /// <param name="unitEnumType">
+        ///     The enum type representing the unit. This must be a valid unit type.
+        /// </param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
-        /// <returns>Unit abbreviations associated with unit.</returns>
+        /// <returns>
+        ///     A read-only list of unit abbreviations associated with the specified unit type.
+        /// </returns>
+        /// <exception cref="ArgumentException">
+        ///     Thrown when the provided <paramref name="unitEnumType" /> is not an enum type.
+        /// </exception>
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when no quantity is found for the specified unit type.
+        /// </exception>
         public IReadOnlyList<string> GetAllUnitAbbreviationsForQuantity(Type unitEnumType, IFormatProvider? formatProvider = null)
         {
-            var allAbbreviations = new List<string>();
-            if (!QuantityInfoLookup.TryGetQuantityByUnitType(unitEnumType, out QuantityInfo? quantityInfo))
+            if (!Quantities.TryGetQuantityByUnitType(unitEnumType, out QuantityInfo? quantityInfo))
             {
-                // TODO I think we should either return empty or throw QuantityNotFoundException here
-                var enumValues = Enum.GetValues(unitEnumType).Cast<Enum>();
-                var all = GetStringUnitPairs(enumValues, formatProvider);
-                return all.Select(pair => pair.Item2).ToList();
+                if (!unitEnumType.IsEnum)
+                {
+                    throw new ArgumentException($"Type {unitEnumType.FullName} is not a supported unit type.");
+                }
+                
+                throw new UnitNotFoundException($"No quantity was found with the specified unit type: '{unitEnumType}'.") { Data = { ["unitType"] = unitEnumType.Name } };
             }
             
+            if (formatProvider is not CultureInfo culture)
+            {
+                culture = CultureInfo.CurrentCulture;
+            }
+
+            var allAbbreviations = new List<string>();
             foreach(UnitInfo unitInfo in quantityInfo.UnitInfos)
             {
-                if(TryGetUnitAbbreviations(unitInfo.UnitKey, formatProvider, out IReadOnlyList<string> abbreviations))
-                {
-                    allAbbreviations.AddRange(abbreviations);
-                }
+                allAbbreviations.AddRange(GetAbbreviationsWithFallbackCulture(unitInfo, culture));
             }
 
             return allAbbreviations;
         }
 
-        internal List<(Enum Unit, string Abbreviation)> GetStringUnitPairs(IEnumerable<Enum> enumValues, IFormatProvider? formatProvider = null)
+        /// <summary>
+        ///    Get all abbreviations for the given unit and culture.
+        /// </summary>
+        /// <param name="unitInfo">The unit.</param>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <returns>The list of abbreviations mapped for this unit. The first in the list is the primary abbreviation used by ToString().</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="unitInfo"/> was null.</exception>
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when the specified <paramref name="unitInfo" /> is not registered with the associated <see cref="Quantities"/>.
+        /// </exception>
+        public IReadOnlyList<string> GetAbbreviations(UnitInfo unitInfo, IFormatProvider? formatProvider = null) // TODO see about removing this overload
         {
-            var unitAbbreviationsPairs = new List<(Enum, string)>();
-            formatProvider ??= CultureInfo.CurrentCulture;
+            if (unitInfo == null) throw new ArgumentNullException(nameof(unitInfo));
+
+            unitInfo = Quantities.GetUnitInfo(unitInfo.UnitKey); // makes sure that the unit is part of the mapped quantities
 
-            foreach(var enumValue in enumValues)
+            if (formatProvider is not CultureInfo culture)
             {
-                if(TryGetUnitAbbreviations(enumValue, formatProvider, out var abbreviations))
-                {
-                    foreach(var abbrev in abbreviations)
-                    {
-                        unitAbbreviationsPairs.Add((enumValue, abbrev));
-                    }
-                }
+                culture = CultureInfo.CurrentCulture;
             }
 
-            return unitAbbreviationsPairs;
+            return GetAbbreviationsWithFallbackCulture(unitInfo, culture);
         }
 
         /// <summary>
         ///    Get all abbreviations for the given unit and culture.
         /// </summary>
         /// <param name="unitInfo">The unit.</param>
-        /// <param name="formatProvider">The culture to get localized abbreviations for. Defaults to <see cref="CultureInfo.CurrentCulture"/>.</param>
+        /// <param name="culture">The culture to get localized abbreviations for.</param>
         /// <returns>The list of abbreviations mapped for this unit. The first in the list is the primary abbreviation used by ToString().</returns>
         /// <exception cref="ArgumentNullException"><paramref name="unitInfo"/> was null.</exception>
-        public IReadOnlyList<string> GetAbbreviations(UnitInfo unitInfo, IFormatProvider? formatProvider = null)
+        internal IReadOnlyList<string> GetAbbreviationsWithFallbackCulture(UnitInfo unitInfo, CultureInfo culture) 
         {
-            if (unitInfo == null) throw new ArgumentNullException(nameof(unitInfo));
-            if (formatProvider is not CultureInfo)
-                formatProvider = CultureInfo.CurrentCulture;
+            IReadOnlyList<string> abbreviations = GetAbbreviationsForCulture(unitInfo, culture);
 
-            var culture = (CultureInfo)formatProvider;
-            var cultureName = GetCultureNameOrEnglish(culture);
-
-            AbbreviationMapKey key = GetAbbreviationMapKey(unitInfo, cultureName);
-
-            IReadOnlyList<string> abbreviations = AbbreviationsMap.GetOrAdd(key,
-                valueFactory: _ => ReadAbbreviationsFromResourceFile(unitInfo.QuantityName, unitInfo.PluralName, culture));
-
-            return abbreviations.Count == 0 && !culture.Equals(FallbackCulture)
-                ? GetAbbreviations(unitInfo, FallbackCulture)
+            return abbreviations.Count == 0 && HasFallbackCulture(culture)
+                ? GetAbbreviationsForCulture(unitInfo, FallbackCulture)
                 : abbreviations;
         }
 
+        internal static bool HasFallbackCulture(CultureInfo culture)
+        {
+            // accounting for the fact that we're using the same abbreviations for both "en-US" and the "Invariant" culture (Name == string.Empty) 
+            return culture.Name != string.Empty && culture.Name != FallbackCulture.Name;
+        }
+
+        internal IReadOnlyList<string> GetAbbreviationsForCulture(UnitInfo unitInfo, CultureInfo culture)
+        {
+            AbbreviationMapKey abbreviationMapKey = GetAbbreviationMapKey(unitInfo, culture);
+#if NET
+            return AbbreviationsMap.GetOrAdd(abbreviationMapKey, ReadAbbreviationsForCulture, (unitInfo, culture));
+            static IReadOnlyList<string> ReadAbbreviationsForCulture(AbbreviationMapKey key, (UnitInfo unitInfo, CultureInfo culture) unitForCulture)
+            {
+                return ReadAbbreviationsFromResourceFile(unitForCulture.unitInfo, unitForCulture.culture);
+            }
+#else
+            // intentionally not using the factory overload here, as it causes an extra allocation for the Func
+            return AbbreviationsMap.TryGetValue(abbreviationMapKey, out IReadOnlyList<string> abbreviations)
+                ? abbreviations
+                : AbbreviationsMap.GetOrAdd(abbreviationMapKey, _ => ReadAbbreviationsFromResourceFile(unitInfo, culture));
+#endif
+        }
+        
         /// <summary>
         ///     Add unit abbreviation for the given <paramref name="unitInfo"/>, such as "kg" for <see cref="MassUnit.Kilogram"/>.
         /// </summary>
         /// <param name="unitInfo">The unit to add for.</param>
-        /// <param name="formatProvider">The culture this abbreviation is for, defaults to <see cref="CultureInfo.CurrentCulture"/>.</param>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <param name="setAsDefault">Whether to set as the primary/default unit abbreviation used by ToString().</param>
         /// <param name="newAbbreviations">One or more abbreviations to add.</param>
-        private void AddAbbreviation(UnitInfo unitInfo, IFormatProvider? formatProvider, bool setAsDefault,
-            params string[] newAbbreviations)
+        private void AddAbbreviation(UnitInfo unitInfo, IFormatProvider? formatProvider, bool setAsDefault, params IEnumerable<string> newAbbreviations)
         {
             if (formatProvider is not CultureInfo culture)
             {
                 culture = CultureInfo.CurrentCulture;
             }
 
-            var cultureName = GetCultureNameOrEnglish(culture);
-
-            AbbreviationMapKey key = GetAbbreviationMapKey(unitInfo, cultureName);
+            AbbreviationMapKey key = GetAbbreviationMapKey(unitInfo, culture);
 
             AbbreviationsMap.AddOrUpdate(key,
                 addValueFactory: _ =>
                 {
-                    List<string> bundledAbbreviations = ReadAbbreviationsFromResourceFile(unitInfo.QuantityName, unitInfo.PluralName, culture).ToList();
+                    List<string> bundledAbbreviations = ReadAbbreviationsFromResourceFile(unitInfo, culture);
                     return AddAbbreviationsToList(setAsDefault, bundledAbbreviations, newAbbreviations);
                 },
                 updateValueFactory: (_, existingReadOnlyList) => AddAbbreviationsToList(setAsDefault, existingReadOnlyList.ToList(), newAbbreviations));
@@ -394,63 +475,32 @@ private static IReadOnlyList<string> AddAbbreviationsToList(bool setAsDefault, L
             return list.AsReadOnly();
         }
 
-        private static AbbreviationMapKey GetAbbreviationMapKey(UnitInfo unitInfo, string cultureName)
+        private static AbbreviationMapKey GetAbbreviationMapKey(UnitInfo unitInfo, CultureInfo culture)
         {
-            return new AbbreviationMapKey(unitInfo.UnitKey, cultureName);
+            // In order to support running in "invariant mode" (DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1) the FallbackCulture is set to the InvariantCulture.
+            // However, if we want to avoid having two entries in the cache ("", "en-US"), we need to map the invariant culture name to the primary localization language.
+            return new AbbreviationMapKey(unitInfo.UnitKey, culture.Name == string.Empty ? "en-US" : culture.Name);
         }
-
-        private static string GetCultureNameOrEnglish(CultureInfo culture)
-        {
-            // Fallback culture is invariant to support DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1,
-            // but we need to map that to the primary localization, English.
-            return culture.Equals(CultureInfo.InvariantCulture)
-                ? "en-US"
-                : culture.Name;
-        }
-
-        private IReadOnlyList<string> ReadAbbreviationsFromResourceFile(string? quantityName, string unitPluralName, CultureInfo culture)
+        
+        private static List<string> ReadAbbreviationsFromResourceFile(UnitInfo unitInfo, CultureInfo culture)
         {
             var abbreviationsList = new List<string>();
-
-            if (quantityName is null) return abbreviationsList.AsReadOnly();
-
+            // we currently don't have any way of providing external resource dictionaries
+            Assembly unitAssembly = unitInfo.UnitKey.UnitType.Assembly;
+            if (unitAssembly != typeof(UnitAbbreviationsCache).Assembly)
+            {
+                return abbreviationsList;
+            }
+            
+            var quantityName = unitInfo.QuantityName;
             string resourceName = $"UnitsNet.GeneratedCode.Resources.{quantityName}";
-            var resourceManager = new ResourceManager(resourceName, GetType().Assembly);
+            var resourceManager = new ResourceManager(resourceName, unitAssembly);
 
-            var abbreviationsString = resourceManager.GetString(unitPluralName, culture);
+            var abbreviationsString = resourceManager.GetString(unitInfo.PluralName, culture);
             if(abbreviationsString is not null)
                 abbreviationsList.AddRange(abbreviationsString.Split(','));
 
-            return abbreviationsList.AsReadOnly();
-        }
-
-        /// <summary>
-        ///     Retrieves a list of unit information objects that match the specified unit abbreviation.
-        /// </summary>
-        /// <param name="formatProvider">An optional format provider to use for culture-specific formatting.</param>
-        /// <param name="unitAbbreviation">The unit abbreviation to search for.</param>
-        /// <returns>A list of <see cref="UnitInfo" /> objects that match the specified unit abbreviation.</returns>
-        /// <remarks>
-        ///     This method performs a case-sensitive match to reduce ambiguity. For example, "cm" could match both
-        ///     <c>LengthUnit.Centimeter</c> (cm) and
-        ///     <c>MolarityUnit.CentimolePerLiter</c> (cM).
-        /// </remarks>
-        internal List<UnitInfo> GetUnitsForAbbreviation(IFormatProvider? formatProvider, string unitAbbreviation)
-        {
-            // TODO this is certain to have terrible performance (especially on the first run)
-            // TODO we should consider adding a (lazy) dictionary for these
-            // Use case-sensitive match to reduce ambiguity.
-            // Don't use UnitParser.TryParse() here, since it allows case-insensitive match per quantity as long as there are no ambiguous abbreviations for
-            // units of that quantity, but here we try all quantities and this results in too high of a chance for ambiguous matches,
-            // such as "cm" matching both LengthUnit.Centimeter (cm) and MolarityUnit.CentimolePerLiter (cM).
-            return QuantityInfoLookup.Infos
-                .SelectMany(quantityInfo => quantityInfo.UnitInfos)
-                .Select(unitInfo => GetAbbreviations(unitInfo, formatProvider).Contains(unitAbbreviation, StringComparer.Ordinal)
-                    ? unitInfo
-                    : null)
-                .Where(unitValue => unitValue != null)
-                .Select(unitValue => unitValue!)
-                .ToList();
+            return abbreviationsList;
         }
     }
 }
diff --git a/UnitsNet/CustomCode/UnitParser.cs b/UnitsNet/CustomCode/UnitParser.cs
index e31612211d..76311f853c 100644
--- a/UnitsNet/CustomCode/UnitParser.cs
+++ b/UnitsNet/CustomCode/UnitParser.cs
@@ -6,309 +6,609 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
+using System.Text;
 using UnitsNet.Units;
 
 // ReSharper disable once CheckNamespace
-namespace UnitsNet
+namespace UnitsNet;
+
+/// <summary>
+///     Parses units given a unit abbreviations cache.
+///     A static instance is created in the <see cref="UnitsNetSetup.Default" />, which is used internally to parse
+///     quantities and units using the
+///     default abbreviations cache for all units and abbreviations defined in the library.
+/// </summary>
+public sealed class UnitParser
 {
     /// <summary>
-    ///     Parses units given a unit abbreviations cache.
-    ///     The static instance <see cref="Default"/> is used internally to parse quantities and units using the
+    ///     Initializes a new instance of the <see cref="UnitParser" /> class using the specified collection of quantity
+    ///     information.
+    /// </summary>
+    /// <param name="quantities">
+    ///     A read-only collection of quantity information used to initialize the unit abbreviations cache.
+    /// </param>
+    public UnitParser(IEnumerable<QuantityInfo> quantities)
+        : this(new UnitAbbreviationsCache(quantities))
+    {
+    }
+
+    internal UnitParser(QuantityInfoLookup quantitiesLookup)
+        : this(new UnitAbbreviationsCache(quantitiesLookup))
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="UnitParser" /> class using the specified unit abbreviations cache.
+    /// </summary>
+    /// <param name="unitAbbreviationsCache">
+    ///     The cache containing unit abbreviations. If null, the default cache will be used.
+    /// </param>
+    public UnitParser(UnitAbbreviationsCache unitAbbreviationsCache)
+    {
+        Abbreviations = unitAbbreviationsCache ?? throw new ArgumentNullException(nameof(unitAbbreviationsCache));
+    }
+
+    /// <summary>
+    ///     Gets the <see cref="UnitAbbreviationsCache" /> instance used by this <see cref="UnitParser" />.
+    ///     This cache contains mappings of unit abbreviations to their corresponding units, enabling efficient
+    ///     parsing and retrieval of unit information.
+    /// </summary>
+    public UnitAbbreviationsCache Abbreviations { get; }
+
+    /// <summary>
+    ///     Gets the collection of quantities available in this <see cref="UnitParser" /> instance.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides access to the <see cref="QuantityInfoLookup" /> that contains
+    ///     information about all quantities and their associated units.
+    /// </remarks>
+    internal QuantityInfoLookup Quantities
+    {
+        get => Abbreviations.Quantities;
+    }
+
+    /// <summary>
+    ///     The default static instance used internally to parse quantities and units using the
     ///     default abbreviations cache for all units and abbreviations defined in the library.
     /// </summary>
-    public sealed class UnitParser
+    public static UnitParser Default => UnitsNetSetup.Default.UnitParser;
+
+    /// <summary>
+    ///     Creates a default instance of the <see cref="UnitParser" /> class with all the built-in unit abbreviations defined
+    ///     in the library.
+    /// </summary>
+    /// <returns>A <see cref="UnitParser" /> instance with the default abbreviations cache.</returns>
+    public static UnitParser CreateDefault()
     {
-        private readonly UnitAbbreviationsCache _unitAbbreviationsCache;
-
-        /// <summary>
-        ///     The default singleton instance for parsing units from the default configured unit abbreviations.
-        /// </summary>
-        /// <remarks>
-        ///     Convenience shortcut for <see cref="UnitsNetSetup"/>.<see cref="UnitsNetSetup.Default"/>.<see cref="UnitsNetSetup.UnitParser"/>.
-        /// </remarks>
-        public static UnitParser Default => UnitsNetSetup.Default.UnitParser;
-
-        /// <summary>
-        ///     Create a parser using the given unit abbreviations cache.
-        /// </summary>
-        /// <param name="unitAbbreviationsCache">The unit abbreviations to parse with.</param>
-        /// <exception cref="ArgumentNullException">No unit abbreviations cache was given.</exception>
-        public UnitParser(UnitAbbreviationsCache unitAbbreviationsCache)
-        {
-            _unitAbbreviationsCache = unitAbbreviationsCache ?? throw new ArgumentNullException(nameof(unitAbbreviationsCache));
-        }
+        return new UnitParser(UnitAbbreviationsCache.CreateDefault());
+    }
+
+    /// <summary>
+    ///     Parses a unit abbreviation for a given unit enumeration type.
+    ///     Example: Parse&lt;LengthUnit&gt;("km") => LengthUnit.Kilometer
+    /// </summary>
+    /// <param name="unitAbbreviation"></param>
+    /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+    /// <typeparam name="TUnitType"></typeparam>
+    /// <returns></returns>
+    public TUnitType Parse<TUnitType>(string unitAbbreviation, IFormatProvider? formatProvider = null)
+        where TUnitType : struct, Enum
+    {
+        if (unitAbbreviation == null) throw new ArgumentNullException(nameof(unitAbbreviation));
+
+        QuantityInfo quantityInfo = Quantities.GetQuantityByUnitType(typeof(TUnitType));
+        return Parse(unitAbbreviation, quantityInfo.UnitInfos, formatProvider).UnitKey.ToUnit<TUnitType>();
+    }
+
+    /// <summary>
+    ///     Parse a unit abbreviation, such as "kg" or "m", to the unit enum value of the enum type
+    ///     <paramref name="unitType" />.
+    /// </summary>
+    /// <param name="unitAbbreviation">
+    ///     Unit abbreviation, such as "kg" or "m" for <see cref="MassUnit.Kilogram" /> and
+    ///     <see cref="LengthUnit.Meter" /> respectively.
+    /// </param>
+    /// <param name="unitType">Unit enum type, such as <see cref="MassUnit" /> and <see cref="LengthUnit" />.</param>
+    /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+    /// <returns>Unit enum value, such as <see cref="MassUnit.Kilogram" />.</returns>
+    /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
+    /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
+    public Enum Parse(string unitAbbreviation, Type unitType, IFormatProvider? formatProvider = null)
+    {
+        if (unitAbbreviation == null) throw new ArgumentNullException(nameof(unitAbbreviation));
 
-        /// <summary>
-        /// Parses a unit abbreviation for a given unit enumeration type.
-        /// Example: Parse&lt;LengthUnit&gt;("km") => LengthUnit.Kilometer
-        /// </summary>
-        /// <param name="unitAbbreviation"></param>
-        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
-        /// <typeparam name="TUnitType"></typeparam>
-        /// <returns></returns>
-        public TUnitType Parse<TUnitType>(string unitAbbreviation, IFormatProvider? formatProvider = null)
-            where TUnitType : struct, Enum
+        QuantityInfo quantityInfo = Quantities.GetQuantityByUnitType(unitType);
+        return Parse(unitAbbreviation, quantityInfo.UnitInfos, formatProvider).Value;
+    }
+
+    /// <summary>
+    ///     Parses the specified unit abbreviation, such as "kg" or "m", to find the corresponding unit information.
+    /// </summary>
+    /// <typeparam name="TUnitInfo">The type of the unit information.</typeparam>
+    /// <param name="unitAbbreviation">The abbreviation of the unit to parse.</param>
+    /// <param name="units">A collection of unit information to search through.</param>
+    /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+    /// <returns>The unit information that matches the specified abbreviation.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="unitAbbreviation" /> is null.</exception>
+    /// <exception cref="UnitNotFoundException">Thrown when no matching unit is found.</exception>
+    /// <exception cref="AmbiguousUnitParseException">Thrown when multiple matching units are found.</exception>
+    internal TUnitInfo Parse<TUnitInfo>(string unitAbbreviation, IReadOnlyList<TUnitInfo> units, IFormatProvider? formatProvider = null)
+        where TUnitInfo : UnitInfo
+    {
+        if (unitAbbreviation == null) throw new ArgumentNullException(nameof(unitAbbreviation));
+        
+        if (formatProvider is not CultureInfo culture)
         {
-            return (TUnitType)Parse(unitAbbreviation, typeof(TUnitType), formatProvider);
+            culture = CultureInfo.CurrentCulture;
         }
-
-        /// <summary>
-        ///     Parse a unit abbreviation, such as "kg" or "m", to the unit enum value of the enum type
-        ///     <paramref name="unitType" />.
-        /// </summary>
-        /// <param name="unitAbbreviation">
-        ///     Unit abbreviation, such as "kg" or "m" for <see cref="MassUnit.Kilogram" /> and
-        ///     <see cref="LengthUnit.Meter" /> respectively.
-        /// </param>
-        /// <param name="unitType">Unit enum type, such as <see cref="MassUnit" /> and <see cref="LengthUnit" />.</param>
-        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
-        /// <returns>Unit enum value, such as <see cref="MassUnit.Kilogram" />.</returns>
-        /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
-        /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
-        public Enum Parse(string unitAbbreviation, Type unitType, IFormatProvider? formatProvider = null)
+        
+        unitAbbreviation = unitAbbreviation.Trim();
+        while (true)
         {
-            if (unitAbbreviation == null) throw new ArgumentNullException(nameof(unitAbbreviation));
-            unitAbbreviation = unitAbbreviation.Trim();
-            Enum[] enumValues = Enum.GetValues(unitType).Cast<Enum>().ToArray();
-            while (true)
+            List<(TUnitInfo UnitInfo, string Abbreviation)> matches = FindMatchingUnits(unitAbbreviation, units, culture);
+            switch (matches.Count)
             {
-                (Enum Unit, string Abbreviation)[] matches = FindMatchingUnits(unitAbbreviation, enumValues, formatProvider);
-                switch(matches.Length)
-                {
-                    case 1:
-                        return matches[0].Unit;
-                    case 0:
-                        // Retry with fallback culture, if different.
-                        if (Equals(formatProvider, UnitAbbreviationsCache.FallbackCulture))
-                        {
-                            throw new UnitNotFoundException($"Unit not found with abbreviation [{unitAbbreviation}] for unit type [{unitType}].");
-                        }
-
-                        formatProvider = UnitAbbreviationsCache.FallbackCulture;
+                case 1:
+                    return matches[0].UnitInfo;
+                case 0:
+                    // Retry with fallback culture, if different.
+                    if (UnitAbbreviationsCache.HasFallbackCulture(culture))
+                    {
+                        culture = UnitAbbreviationsCache.FallbackCulture;
                         continue;
-                    default:
-                        var unitsCsv = string.Join(", ", matches.Select(x => $"{Enum.GetName(unitType, x.Unit)} (\"{x.Abbreviation}\")").OrderBy(x => x));
-                        throw new AmbiguousUnitParseException($"Cannot parse \"{unitAbbreviation}\" since it matches multiple units: {unitsCsv}.");
-                }
+                    }
+
+                    throw new UnitNotFoundException($"Unit not found with abbreviation [{unitAbbreviation}] for unit type [{typeof(TUnitInfo)}].");
+                default:
+                    var unitsCsv = string.Join(", ", matches.Select(x => $"{x.UnitInfo.Name} (\"{x.Abbreviation}\")").OrderBy(x => x));
+                    throw new AmbiguousUnitParseException($"Cannot parse \"{unitAbbreviation}\" since it matches multiple units: {unitsCsv}.");
             }
         }
+    }
+    
 
-        internal static string NormalizeUnitString(string unitAbbreviation)
+    internal static string NormalizeUnitString(string unitAbbreviation)
+    {
+        var abbreviationLength = unitAbbreviation.Length;
+        if (abbreviationLength == 0)
         {
-            // remove all whitespace in the string
-            unitAbbreviation = new string(unitAbbreviation.Where(c => !char.IsWhiteSpace(c)).ToArray());
-
-            unitAbbreviation = unitAbbreviation.Replace("^-9", "⁻⁹");
-            unitAbbreviation = unitAbbreviation.Replace("^-8", "⁻⁸");
-            unitAbbreviation = unitAbbreviation.Replace("^-7", "⁻⁷");
-            unitAbbreviation = unitAbbreviation.Replace("^-6", "⁻⁶");
-            unitAbbreviation = unitAbbreviation.Replace("^-5", "⁻⁵");
-            unitAbbreviation = unitAbbreviation.Replace("^-4", "⁻⁴");
-            unitAbbreviation = unitAbbreviation.Replace("^-3", "⁻³");
-            unitAbbreviation = unitAbbreviation.Replace("^-2", "⁻²");
-            unitAbbreviation = unitAbbreviation.Replace("^-1", "⁻¹");
-            unitAbbreviation = unitAbbreviation.Replace("^1", "");
-            unitAbbreviation = unitAbbreviation.Replace("^2", "²");
-            unitAbbreviation = unitAbbreviation.Replace("^3", "³");
-            unitAbbreviation = unitAbbreviation.Replace("^4", "⁴");
-            unitAbbreviation = unitAbbreviation.Replace("^5", "⁵");
-            unitAbbreviation = unitAbbreviation.Replace("^6", "⁶");
-            unitAbbreviation = unitAbbreviation.Replace("^7", "⁷");
-            unitAbbreviation = unitAbbreviation.Replace("^8", "⁸");
-            unitAbbreviation = unitAbbreviation.Replace("^9", "⁹");
-            unitAbbreviation = unitAbbreviation.Replace("*", "·");
-            // "\u03bc" = Lower case Greek letter 'Mu'
-            // "\u00b5" = Micro sign
-            unitAbbreviation = unitAbbreviation.Replace("\u03bc", "\u00b5");
-
             return unitAbbreviation;
         }
 
-        /// <summary>
-        /// Try to parse a unit abbreviation.
-        /// </summary>
-        /// <param name="unitAbbreviation">The string value.</param>
-        /// <param name="unit">The unit enum value as out result.</param>
-        /// <typeparam name="TUnitType">Type of unit enum.</typeparam>
-        /// <returns>True if successful.</returns>
-        public bool TryParse<TUnitType>([NotNullWhen(true)]string? unitAbbreviation, out TUnitType unit)
-            where TUnitType : struct, Enum
+        // Remove all whitespace using StringBuilder
+        var sb = new StringBuilder(abbreviationLength);
+        for (var i = 0; i < unitAbbreviation.Length; i++)
         {
-            return TryParse(unitAbbreviation, null, out unit);
+            var character = unitAbbreviation[i];
+            if (!char.IsWhiteSpace(character))
+            {
+                sb.Append(character);
+            }
         }
 
-        /// <summary>
-        /// Try to parse a unit abbreviation.
-        /// </summary>
-        /// <param name="unitAbbreviation">The string value.</param>
-        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
-        /// <param name="unit">The unit enum value as out result.</param>
-        /// <typeparam name="TUnitType">Type of unit enum.</typeparam>
-        /// <returns>True if successful.</returns>
-        public bool TryParse<TUnitType>([NotNullWhen(true)]string? unitAbbreviation, IFormatProvider? formatProvider, out TUnitType unit)
-            where TUnitType : struct, Enum
+        // Perform replacements using StringBuilder
+        sb.Replace("^-9", "⁻⁹")
+            .Replace("^-8", "⁻⁸")
+            .Replace("^-7", "⁻⁷")
+            .Replace("^-6", "⁻⁶")
+            .Replace("^-5", "⁻⁵")
+            .Replace("^-4", "⁻⁴")
+            .Replace("^-3", "⁻³")
+            .Replace("^-2", "⁻²")
+            .Replace("^-1", "⁻¹")
+            .Replace("^1", "")
+            .Replace("^2", "²")
+            .Replace("^3", "³")
+            .Replace("^4", "⁴")
+            .Replace("^5", "⁵")
+            .Replace("^6", "⁶")
+            .Replace("^7", "⁷")
+            .Replace("^8", "⁸")
+            .Replace("^9", "⁹")
+            .Replace("*", "·")
+            .Replace("\u03bc", "\u00b5"); // Greek letter 'Mu' to Micro sign
+        
+        return sb.ToString();
+    }
+
+    /// <summary>
+    ///     Try to parse a unit abbreviation.
+    /// </summary>
+    /// <param name="unitAbbreviation">The string value.</param>
+    /// <param name="unit">The unit enum value as out result.</param>
+    /// <typeparam name="TUnitType">Type of unit enum.</typeparam>
+    /// <returns>True if successful.</returns>
+    public bool TryParse<TUnitType>([NotNullWhen(true)] string? unitAbbreviation, out TUnitType unit)
+        where TUnitType : struct, Enum
+    {
+        return TryParse(unitAbbreviation, null, out unit);
+    }
+
+    /// <summary>
+    ///     Try to parse a unit abbreviation.
+    /// </summary>
+    /// <param name="unitAbbreviation">The string value.</param>
+    /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+    /// <param name="unit">The unit enum value as out result.</param>
+    /// <typeparam name="TUnitType">Type of unit enum.</typeparam>
+    /// <returns>True if successful.</returns>
+    public bool TryParse<TUnitType>([NotNullWhen(true)] string? unitAbbreviation, IFormatProvider? formatProvider, out TUnitType unit)
+        where TUnitType : struct, Enum
+    {
+        if (!TryParse(unitAbbreviation, typeof(TUnitType), formatProvider, out Enum? unitObj))
         {
             unit = default;
+            return false;
+        }
+
+        unit = (TUnitType)unitObj;
+        return true;
+    }
+
+    /// <summary>
+    ///     Try to parse a unit abbreviation.
+    /// </summary>
+    /// <param name="unitAbbreviation">The string value.</param>
+    /// <param name="unitType">Type of unit enum.</param>
+    /// <param name="unit">The unit enum value as out result.</param>
+    /// <returns>True if successful.</returns>
+    public bool TryParse([NotNullWhen(true)]string? unitAbbreviation, Type unitType, [NotNullWhen(true)] out Enum? unit)
+    {
+        return TryParse(unitAbbreviation, unitType, null, out unit);
+    }
 
-            if (!TryParse(unitAbbreviation, typeof(TUnitType), formatProvider, out var unitObj))
-                return false;
+    /// <summary>
+    ///     Try to parse a unit abbreviation.
+    /// </summary>
+    /// <param name="unitAbbreviation">The string value.</param>
+    /// <param name="unitType">Type of unit enum.</param>
+    /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+    /// <param name="unit">The unit enum value as out result.</param>
+    /// <returns>True if successful.</returns>
+    public bool TryParse([NotNullWhen(true)] string? unitAbbreviation, Type unitType, IFormatProvider? formatProvider, [NotNullWhen(true)] out Enum? unit)
+    {
+        if (unitAbbreviation == null)
+        {
+            unit = null;
+            return false;
+        }
 
-            unit = (TUnitType)unitObj;
+        if (Quantities.TryGetQuantityByUnitType(unitType, out QuantityInfo? quantityInfo) &&
+            TryParse(unitAbbreviation, quantityInfo.UnitInfos, formatProvider, out UnitInfo? unitInfo))
+        {
+            unit = unitInfo.Value;
             return true;
         }
 
-        /// <summary>
-        /// Try to parse a unit abbreviation.
-        /// </summary>
-        /// <param name="unitAbbreviation">The string value.</param>
-        /// <param name="unitType">Type of unit enum.</param>
-        /// <param name="unit">The unit enum value as out result.</param>
-        /// <returns>True if successful.</returns>
-        public bool TryParse([NotNullWhen(true)] string? unitAbbreviation, Type unitType, [NotNullWhen(true)] out Enum? unit)
+        unit = null;
+        return false;
+    }
+
+    /// <summary>
+    ///     Attempts to parse the specified unit abbreviation, such as "kg" or "m", into a unit of the specified type.
+    /// </summary>
+    /// <typeparam name="TUnit">The type of the unit enumeration.</typeparam>
+    /// <param name="unitAbbreviation">The unit abbreviation to parse.</param>
+    /// <param name="quantityInfo">The quantity information that provides context for the unit.</param>
+    /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+    /// <param name="unit">
+    ///     When this method returns, contains the parsed unit if the parsing succeeded, or <c>null</c> if the parsing failed.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the unit abbreviation was successfully parsed; otherwise, <c>false</c>.
+    /// </returns>
+    internal bool TryParse<TUnit>([NotNullWhen(true)] string? unitAbbreviation, QuantityInfo<TUnit> quantityInfo, IFormatProvider? formatProvider,
+        out TUnit unit)
+        where TUnit : struct, Enum
+    {
+        if (TryParse(unitAbbreviation, quantityInfo.UnitInfos, formatProvider, out UnitInfo<TUnit>? unitInfo))
         {
-            return TryParse(unitAbbreviation, unitType, null, out unit);
+            unit = unitInfo.Value;
+            return true;
         }
 
-        /// <summary>
-        /// Try to parse a unit abbreviation.
-        /// </summary>
-        /// <param name="unitAbbreviation">The string value.</param>
-        /// <param name="unitType">Type of unit enum.</param>
-        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
-        /// <param name="unit">The unit enum value as out result.</param>
-        /// <returns>True if successful.</returns>
-        public bool TryParse([NotNullWhen(true)] string? unitAbbreviation, Type unitType, IFormatProvider? formatProvider, [NotNullWhen(true)] out Enum? unit)
+        unit = default;
+        return false;
+    }
+    
+    /// <summary>
+    ///     Attempts to match the provided unit abbreviation against the defined abbreviations for the units and returns the
+    ///     matching unit information.
+    /// </summary>
+    /// <typeparam name="TUnitInfo">The type of the unit information.</typeparam>
+    /// <param name="unitAbbreviation">The unit abbreviation to match.</param>
+    /// <param name="units">The collection of units to match against.</param>
+    /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+    /// <param name="unit">
+    ///     When this method returns, contains the matching unit information if the match was successful; otherwise, the
+    ///     default value for the type of the unit parameter.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the unit abbreviation was successfully matched; otherwise, <c>false</c>.
+    /// </returns>
+    internal bool TryParse<TUnitInfo>([NotNullWhen(true)] string? unitAbbreviation, IReadOnlyList<TUnitInfo> units, IFormatProvider? formatProvider,
+        [NotNullWhen(true)] out TUnitInfo? unit)
+        where TUnitInfo : UnitInfo
+    {
+        unit = null;
+        if (unitAbbreviation == null)
         {
-            unit = null;
-            if (unitAbbreviation == null)
-            {
-                return false;
-            }
+            return false;
+        }
+        
+        unitAbbreviation = unitAbbreviation.Trim();
+        
+        if (formatProvider is not CultureInfo culture)
+        {
+            culture = CultureInfo.CurrentCulture;
+        }
+        
+        List<(TUnitInfo UnitInfo, string Abbreviation)> matches = FindMatchingUnits(unitAbbreviation, units, culture);
+        
+        if (matches.Count == 1)
+        {
+            unit = matches[0].UnitInfo;
+            return true;
+        }
+
+        if (matches.Count != 0 || !UnitAbbreviationsCache.HasFallbackCulture(culture))
+        {
+            return false; // either there are duplicates or nothing was matched and we're already using the fallback culture
+        }
 
-            unitAbbreviation = unitAbbreviation.Trim();
-            Enum[] enumValues = Enum.GetValues(unitType).Cast<Enum>().ToArray();
-            (Enum Unit, string Abbreviation)[] matches = FindMatchingUnits(unitAbbreviation, enumValues, formatProvider);
+        // retry the lookup using the fallback culture
+        matches = FindMatchingUnits(unitAbbreviation, units, UnitAbbreviationsCache.FallbackCulture);
+        if (matches.Count != 1)
+        {
+            return false;
+        }
+        
+        unit = matches[0].UnitInfo;
+        return true;
+    }
 
-            if (matches.Length == 1)
-            {
-                unit = matches[0].Unit;
-                return true;
-            }
+    private List<(TUnitInfo UnitInfo, string Abbreviation)> FindMatchingUnits<TUnitInfo>(string unitAbbreviation, IReadOnlyList<TUnitInfo> units,
+        CultureInfo culture)
+        where TUnitInfo : UnitInfo
+    {
+        List<(TUnitInfo UnitInfo, string Abbreviation)> caseInsensitiveMatches = FindMatchingUnitsForCulture(units, unitAbbreviation, culture, StringComparison.OrdinalIgnoreCase);
 
-            if (matches.Length != 0 || Equals(formatProvider, UnitAbbreviationsCache.FallbackCulture))
+        if (caseInsensitiveMatches.Count == 0)
+        {
+            var normalizeUnitString = NormalizeUnitString(unitAbbreviation);
+            if (unitAbbreviation == normalizeUnitString)
             {
-                return false; // either there are duplicates or nothing was matched and we're already using the fallback culture
+                return caseInsensitiveMatches;
             }
 
-            // retry the lookup using the fallback culture
-            matches = FindMatchingUnits(unitAbbreviation, enumValues, UnitAbbreviationsCache.FallbackCulture);
-            if (matches.Length != 1)
+            unitAbbreviation = normalizeUnitString;
+            caseInsensitiveMatches = FindMatchingUnitsForCulture(units, unitAbbreviation, culture, StringComparison.OrdinalIgnoreCase);
+            if (caseInsensitiveMatches.Count == 0)
             {
-                return false;
+                return caseInsensitiveMatches;
             }
+        }
 
-            unit = matches[0].Unit;
-            return true;
+        var nbAbbreviationsFound = caseInsensitiveMatches.Count;
+        if (nbAbbreviationsFound == 1)
+        {
+            return caseInsensitiveMatches;
         }
 
-        private (Enum Unit, string Abbreviation)[] FindMatchingUnits(string unitAbbreviation, IEnumerable<Enum> enumValues, IFormatProvider? formatProvider)
+        // Narrow the search if too many hits, for example Megabar "Mbar" and Millibar "mbar" need to be distinguished
+        var caseSensitiveMatches = new List<(TUnitInfo UnitInfo, string Abbreviation)>(nbAbbreviationsFound);
+        for (var i = 0; i < nbAbbreviationsFound; i++)
         {
-            // TODO see about optimizing this method: both Parse and TryParse only care about having one match (in case of a failure we could return the number of matches)
-            List<(Enum Unit, string Abbreviation)> stringUnitPairs = _unitAbbreviationsCache.GetStringUnitPairs(enumValues, formatProvider);
-            (Enum Unit, string Abbreviation)[] matches =
-                stringUnitPairs.Where(pair => pair.Abbreviation.Equals(unitAbbreviation, StringComparison.OrdinalIgnoreCase)).ToArray();
+            (TUnitInfo UnitInfo, string Abbreviation) match = caseInsensitiveMatches[i];
+            if (unitAbbreviation == match.Abbreviation)
+            {
+                caseSensitiveMatches.Add(match);
+            }
+        }
 
-            // No match? Retry after normalizing the unit abbreviation.
-            if (matches.Length == 0)
+        return caseSensitiveMatches.Count == 0 ? caseInsensitiveMatches : caseSensitiveMatches;
+    }
+
+    private List<(TUnitInfo UnitInfo, string Abbreviation)> FindMatchingUnitsForCulture<TUnitInfo>(IReadOnlyList<TUnitInfo> unitInfos, string unitAbbreviation,
+        CultureInfo culture, StringComparison comparison)
+        where TUnitInfo: UnitInfo
+    {
+        var unitAbbreviationsPairs = new List<(TUnitInfo, string)>();
+        var nbUnits = unitInfos.Count;
+        for (var i = 0; i < nbUnits; i++)
+        {
+            TUnitInfo unitInfo = unitInfos[i];
+            IReadOnlyList<string> abbreviations = Abbreviations.GetAbbreviationsForCulture(unitInfo, culture);
+            var nbAbbreviations = abbreviations.Count;
+            for (var p = 0; p < nbAbbreviations; p++)
             {
-                var normalizeUnitString = NormalizeUnitString(unitAbbreviation);
-                if (unitAbbreviation != normalizeUnitString)
+                var abbreviation = abbreviations[p];
+                if (unitAbbreviation.Equals(abbreviation, comparison))
                 {
-                    unitAbbreviation = normalizeUnitString;
-                    matches = stringUnitPairs.Where(pair => pair.Abbreviation.Equals(unitAbbreviation, StringComparison.OrdinalIgnoreCase)).ToArray();
+                    unitAbbreviationsPairs.Add((unitInfo, abbreviation));
                 }
             }
+        }
 
-            if (matches.Length == 1)
-            {
-                return matches;
-            }
+        return unitAbbreviationsPairs;
+    }
 
-            // Narrow the search if too many hits, for example Megabar "Mbar" and Millibar "mbar" need to be distinguished
-            (Enum Unit, string Abbreviation)[] caseSensitiveMatches = stringUnitPairs.Where(pair => pair.Abbreviation.Equals(unitAbbreviation)).ToArray();
-            return caseSensitiveMatches.Length == 0 ? matches : caseSensitiveMatches;
-        }
 
-        /// <summary>
-        ///     Retrieves the unit information from the given unit abbreviation.
-        /// </summary>
-        /// <remarks>
-        ///     This method is currently not optimized for performance and will enumerate all units and their unit abbreviations
-        ///     each time.<br />
-        ///     Unit abbreviation matching in the <see cref="TryParse{TUnitType}(string?,out TUnitType)" />
-        ///     overload is case-insensitive.<br />
-        ///     <br />
-        ///     This will fail if more than one unit across all quantities share the same unit abbreviation.<br />
-        /// </remarks>
-        /// <param name="unitAbbreviation">The unit abbreviation to parse.</param>
-        /// <param name="formatProvider">The format provider to use for culture-specific formatting. Can be null.</param>
-        /// <returns>The unit information corresponding to the given unit abbreviation.</returns>
-        /// <exception cref="UnitNotFoundException">
-        ///     Thrown when the unit abbreviation is not recognized as a valid unit for the specified culture.
-        /// </exception>
-        /// <exception cref="AmbiguousUnitParseException">
-        ///     Thrown when multiple units are found matching the given unit abbreviation.
-        /// </exception>
-        internal UnitInfo GetUnitFromAbbreviation(string unitAbbreviation, IFormatProvider? formatProvider)
+    private List<(UnitInfo UnitInfo, string Abbreviation)> FindAllMatchingUnitsForCulture(string unitAbbreviation, CultureInfo culture,
+        StringComparison comparison)
+    {
+        var unitAbbreviationsPairs = new List<(UnitInfo, string)>();
+        foreach (QuantityInfo quantityInfo in Quantities.Infos)
         {
-            List<UnitInfo> units = _unitAbbreviationsCache.GetUnitsForAbbreviation(formatProvider, unitAbbreviation);
-            return units.Count switch
+            IReadOnlyList<UnitInfo> unitInfos = quantityInfo.UnitInfos;
+            var nbUnits = unitInfos.Count;
+            for (var i = 0; i < nbUnits; i++)
             {
-                0 => throw new UnitNotFoundException(
-                    $"The unit abbreviation '{unitAbbreviation}' is not recognized as a valid unit for the specified culture."),
-                1 => units[0],
-                _ => throw new AmbiguousUnitParseException(
-                    $"Cannot parse \"{unitAbbreviation}\" since it matches multiple units: {string.Join(", ", units.Select(x => x.Name).OrderBy(x => x))}.")
-            };
+                UnitInfo unitInfo = unitInfos[i];
+                IReadOnlyList<string> abbreviations = Abbreviations.GetAbbreviationsForCulture(unitInfo, culture);
+                var nbAbbreviations = abbreviations.Count;
+                for (var p = 0; p < nbAbbreviations; p++)
+                {
+                    var abbreviation = abbreviations[p];
+                    if (unitAbbreviation.Equals(abbreviation, comparison))
+                    {
+                        unitAbbreviationsPairs.Add((unitInfo, abbreviation));
+                    }
+                }
+            }
         }
 
-        /// <summary>
-        ///     Attempts to parse the specified unit abbreviation into an <see cref="UnitInfo" /> object.
-        /// </summary>
-        /// <remarks>
-        ///     This method is currently not optimized for performance and will enumerate all units and their unit abbreviations
-        ///     each time.<br />
-        ///     Unit abbreviation matching in the <see cref="TryParse{TUnitType}(string,out TUnitType)" />
-        ///     overload is case-insensitive.<br />
-        ///     <br />
-        ///     This will fail if more than one unit across all quantities share the same unit abbreviation.<br />
-        /// </remarks>
-        /// <param name="unitAbbreviation">The unit abbreviation to parse.</param>
-        /// <param name="formatProvider">The format provider to use for parsing, or <c>null</c> to use the current culture.</param>
-        /// <param name="unit">
-        ///     When this method returns, contains the parsed <see cref="UnitInfo" /> object if the parsing succeeded,
-        ///     or <c>null</c> if the parsing failed. This parameter is passed uninitialized.
-        /// </param>
-        /// <returns>
-        ///     <c>true</c> if the unit abbreviation was successfully parsed; otherwise, <c>false</c>.
-        /// </returns>
-        internal bool TryGetUnitFromAbbreviation([NotNullWhen(true)]string? unitAbbreviation, IFormatProvider? formatProvider, [NotNullWhen(true)] out UnitInfo? unit)
+        return unitAbbreviationsPairs;
+    }
+
+
+    /// <summary>
+    ///     Retrieves the unit information corresponding to the specified unit abbreviation.
+    /// </summary>
+    /// <param name="unitAbbreviation">The unit abbreviation to parse. Cannot be null or empty.</param>
+    /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+    /// <returns>The <see cref="UnitInfo" /> instance representing the parsed unit.</returns>
+    /// <exception cref="ArgumentNullException">
+    ///     Thrown when <paramref name="unitAbbreviation" /> is null.
+    /// </exception>
+    /// <exception cref="UnitNotFoundException">
+    ///     Thrown when the unit abbreviation is not recognized as a valid unit for the specified culture.
+    /// </exception>
+    /// <exception cref="AmbiguousUnitParseException">
+    ///     Thrown when multiple units match the given unit abbreviation, making the result ambiguous.
+    /// </exception>
+    /// <remarks>
+    ///     This method performs a series of searches to find the unit:
+    ///     <list type="number">
+    ///         <item>Case-sensitive search using the current culture.</item>
+    ///         <item>Case-sensitive search using the fallback culture, if applicable.</item>
+    ///         <item>Case-insensitive search.</item>
+    ///     </list>
+    ///     Note that this method is not optimized for performance, as it enumerates all units and their abbreviations
+    ///     during each invocation.
+    /// </remarks>
+    public UnitInfo GetUnitFromAbbreviation(string unitAbbreviation, IFormatProvider? formatProvider)
+    {
+        if (unitAbbreviation == null) throw new ArgumentNullException(nameof(unitAbbreviation));
+        
+        if (formatProvider is not CultureInfo culture)
+        {
+            culture = CultureInfo.CurrentCulture;
+        }
+        
+        unitAbbreviation = unitAbbreviation.Trim();
+        StringComparison comparison = StringComparison.Ordinal;
+        while (true)
         {
-            if (unitAbbreviation == null)
+            List<(UnitInfo UnitInfo, string Abbreviation)> matches = FindAllMatchingUnitsForCulture(unitAbbreviation, culture, comparison);
+            switch (matches.Count)
             {
-                unit = null;
-                return false;
-            }
+                case 1:
+                    return matches[0].UnitInfo;
+                case 0:
+                    // Retry with fallback culture, if different.
+                    if (UnitAbbreviationsCache.HasFallbackCulture(culture))
+                    {
+                        culture = UnitAbbreviationsCache.FallbackCulture;
+                        continue;
+                    }
+                    
+                    var normalizedUnitString = NormalizeUnitString(unitAbbreviation);
+                    if (normalizedUnitString != unitAbbreviation)
+                    {
+                        unitAbbreviation = normalizedUnitString;
+                        continue;
+                    }
 
-            List<UnitInfo> units = _unitAbbreviationsCache.GetUnitsForAbbreviation(formatProvider, unitAbbreviation);
-            if (units.Count == 1)
-            {
-                unit = units[0];
-                return true;
+                    if (comparison == StringComparison.Ordinal)
+                    {
+                        comparison = StringComparison.OrdinalIgnoreCase;
+                        continue;
+                    }
+
+                    throw new UnitNotFoundException($"Unit not found with abbreviation [{unitAbbreviation}].");
+                default:
+                    var unitsCsv = string.Join(", ", matches.Select(x => $"{x.UnitInfo.Name} (\"{x.Abbreviation}\")").OrderBy(x => x));
+                    throw new AmbiguousUnitParseException($"Cannot parse \"{unitAbbreviation}\" since it matches multiple units: {unitsCsv}.");
             }
+        }
+    }
 
+    /// <summary>
+    ///     Attempts to parse the specified unit abbreviation into an <see cref="UnitInfo" /> object.
+    /// </summary>
+    /// <param name="unitAbbreviation">The unit abbreviation to parse.</param>
+    /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+    /// <param name="unit">
+    ///     When this method returns, contains the parsed <see cref="UnitInfo" /> object if the parsing succeeded,
+    ///     or <c>null</c> if the parsing failed. This parameter is passed uninitialized.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the unit abbreviation was successfully parsed; otherwise, <c>false</c>.
+    /// </returns>
+    /// <remarks>
+    ///     This method performs a series of searches to find the unit:
+    ///     <list type="number">
+    ///         <item>Case-sensitive search using the current culture.</item>
+    ///         <item>Case-sensitive search using the fallback culture, if applicable.</item>
+    ///         <item>Case-insensitive search.</item>
+    ///     </list>
+    ///     Note that this method is not optimized for performance, as it enumerates all units and their abbreviations
+    ///     during each invocation.
+    /// </remarks>
+    public bool TryGetUnitFromAbbreviation([NotNullWhen(true)]string? unitAbbreviation, IFormatProvider? formatProvider, [NotNullWhen(true)] out UnitInfo? unit)
+    {
+        if (unitAbbreviation == null)
+        {
             unit = null;
             return false;
         }
+        
+        unitAbbreviation = unitAbbreviation.Trim();
+        
+        if (formatProvider is not CultureInfo culture)
+        {
+            culture = CultureInfo.CurrentCulture;
+        }
+        
+        StringComparison comparison = StringComparison.Ordinal;
+        while (true)
+        {
+            List<(UnitInfo UnitInfo, string Abbreviation)> matches = FindAllMatchingUnitsForCulture(unitAbbreviation, culture, comparison);
+            switch (matches.Count)
+            {
+                case 1:
+                    unit = matches[0].UnitInfo;
+                    return true;
+                case 0:
+                    // Retry with fallback culture, if different.
+                    if (UnitAbbreviationsCache.HasFallbackCulture(culture))
+                    {
+                        culture = UnitAbbreviationsCache.FallbackCulture;
+                        continue;
+                    }
+                    
+                    var normalizedUnitString = NormalizeUnitString(unitAbbreviation);
+                    if (normalizedUnitString != unitAbbreviation)
+                    {
+                        unitAbbreviation = normalizedUnitString;
+                        continue;
+                    }
+
+                    if (comparison == StringComparison.Ordinal)
+                    {
+                        comparison = StringComparison.OrdinalIgnoreCase;
+                        continue;
+                    }
+                    
+                    unit = null;
+                    return false;
+                default:
+                {
+                    unit = null;
+                    return false;
+                }
+            }
+        }
     }
 }
diff --git a/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs b/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
index 6526699053..a3da931238 100644
--- a/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
@@ -601,7 +601,7 @@ public static AbsorbedDoseOfIonizingRadiationUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static AbsorbedDoseOfIonizingRadiationUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<AbsorbedDoseOfIonizingRadiationUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AbsorbedDoseOfIonizingRadiationUnit)"/>
@@ -622,7 +622,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AbsorbedDose
         /// <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 AbsorbedDoseOfIonizingRadiationUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<AbsorbedDoseOfIonizingRadiationUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
index c998ba68e4..9e06043f1c 100644
--- a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
@@ -573,7 +573,7 @@ public static AccelerationUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static AccelerationUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<AccelerationUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AccelerationUnit)"/>
@@ -594,7 +594,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out Acceleration
         /// <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 AccelerationUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<AccelerationUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
index 70442d991c..507902a183 100644
--- a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
@@ -622,7 +622,7 @@ public static AmountOfSubstanceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static AmountOfSubstanceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<AmountOfSubstanceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AmountOfSubstanceUnit)"/>
@@ -643,7 +643,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AmountOfSubs
         /// <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 AmountOfSubstanceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<AmountOfSubstanceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
index 824ccb8c40..7b5387f888 100644
--- a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
@@ -392,7 +392,7 @@ public static AmplitudeRatioUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static AmplitudeRatioUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<AmplitudeRatioUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AmplitudeRatioUnit)"/>
@@ -413,7 +413,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AmplitudeRat
         /// <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 AmplitudeRatioUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<AmplitudeRatioUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
index 20072f8797..746fed8f0c 100644
--- a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
@@ -573,7 +573,7 @@ public static AngleUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static AngleUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<AngleUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AngleUnit)"/>
@@ -594,7 +594,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AngleUnit un
         /// <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 AngleUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<AngleUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Area.g.cs b/UnitsNet/GeneratedCode/Quantities/Area.g.cs
index 4a5eed40b2..172ad23e41 100644
--- a/UnitsNet/GeneratedCode/Quantities/Area.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Area.g.cs
@@ -584,7 +584,7 @@ public static AreaUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static AreaUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<AreaUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AreaUnit)"/>
@@ -605,7 +605,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AreaUnit uni
         /// <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 AreaUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<AreaUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
index 0092dc509e..225bbc013f 100644
--- a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
@@ -393,7 +393,7 @@ public static AreaDensityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static AreaDensityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<AreaDensityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AreaDensityUnit)"/>
@@ -414,7 +414,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AreaDensityU
         /// <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 AreaDensityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<AreaDensityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
index 6ea9a72cb7..4dc2556bc6 100644
--- a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
@@ -442,7 +442,7 @@ public static AreaMomentOfInertiaUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static AreaMomentOfInertiaUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<AreaMomentOfInertiaUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AreaMomentOfInertiaUnit)"/>
@@ -463,7 +463,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AreaMomentOf
         /// <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 AreaMomentOfInertiaUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<AreaMomentOfInertiaUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
index f073a23c80..5870dd4e18 100644
--- a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
@@ -761,7 +761,7 @@ public static BitRateUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static BitRateUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<BitRateUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.BitRateUnit)"/>
@@ -782,7 +782,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out BitRateUnit
         /// <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 BitRateUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<BitRateUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
index 3a1c2d2deb..4946afeea5 100644
--- a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
@@ -394,7 +394,7 @@ public static BrakeSpecificFuelConsumptionUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static BrakeSpecificFuelConsumptionUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<BrakeSpecificFuelConsumptionUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.BrakeSpecificFuelConsumptionUnit)"/>
@@ -415,7 +415,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out BrakeSpecifi
         /// <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 BrakeSpecificFuelConsumptionUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<BrakeSpecificFuelConsumptionUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
index ac827c70b0..5781ba09eb 100644
--- a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
@@ -441,7 +441,7 @@ public static CoefficientOfThermalExpansionUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static CoefficientOfThermalExpansionUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<CoefficientOfThermalExpansionUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.CoefficientOfThermalExpansionUnit)"/>
@@ -462,7 +462,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out CoefficientO
         /// <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 CoefficientOfThermalExpansionUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<CoefficientOfThermalExpansionUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs
index 4c83b57d46..5b8c6f92ae 100644
--- a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs
@@ -454,7 +454,7 @@ public static CompressibilityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static CompressibilityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<CompressibilityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.CompressibilityUnit)"/>
@@ -475,7 +475,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out Compressibil
         /// <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 CompressibilityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<CompressibilityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Density.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
index 10d87c4116..3c014542de 100644
--- a/UnitsNet/GeneratedCode/Quantities/Density.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
@@ -1250,7 +1250,7 @@ public static DensityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static DensityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<DensityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.DensityUnit)"/>
@@ -1271,7 +1271,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out DensityUnit
         /// <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 DensityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<DensityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/DoseAreaProduct.g.cs b/UnitsNet/GeneratedCode/Quantities/DoseAreaProduct.g.cs
index abeb8f0ed7..bfd99bd4c9 100644
--- a/UnitsNet/GeneratedCode/Quantities/DoseAreaProduct.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/DoseAreaProduct.g.cs
@@ -665,7 +665,7 @@ public static DoseAreaProductUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static DoseAreaProductUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<DoseAreaProductUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.DoseAreaProductUnit)"/>
@@ -686,7 +686,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out DoseAreaProd
         /// <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 DoseAreaProductUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<DoseAreaProductUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
index 56545f36f8..24f12ae393 100644
--- a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
@@ -551,7 +551,7 @@ public static DurationUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static DurationUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<DurationUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.DurationUnit)"/>
@@ -572,7 +572,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out DurationUnit
         /// <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 DurationUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<DurationUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
index 179bc68925..3c6756c7df 100644
--- a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
@@ -509,7 +509,7 @@ public static DynamicViscosityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static DynamicViscosityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<DynamicViscosityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.DynamicViscosityUnit)"/>
@@ -530,7 +530,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out DynamicVisco
         /// <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 DynamicViscosityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<DynamicViscosityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
index 17dce29980..ca1eee769b 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
@@ -602,7 +602,7 @@ public static ElectricAdmittanceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricAdmittanceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricAdmittanceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricAdmittanceUnit)"/>
@@ -623,7 +623,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricAdmi
         /// <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 ElectricAdmittanceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricAdmittanceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricApparentEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricApparentEnergy.g.cs
index 9145550d66..0c699e0c30 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricApparentEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricApparentEnergy.g.cs
@@ -390,7 +390,7 @@ public static ElectricApparentEnergyUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricApparentEnergyUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricApparentEnergyUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricApparentEnergyUnit)"/>
@@ -411,7 +411,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricAppa
         /// <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 ElectricApparentEnergyUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricApparentEnergyUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricApparentPower.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricApparentPower.g.cs
index 6358382f46..a149b65326 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricApparentPower.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricApparentPower.g.cs
@@ -441,7 +441,7 @@ public static ElectricApparentPowerUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricApparentPowerUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricApparentPowerUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricApparentPowerUnit)"/>
@@ -462,7 +462,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricAppa
         /// <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 ElectricApparentPowerUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricApparentPowerUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCapacitance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCapacitance.g.cs
index e3f0778380..5cb5215d69 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCapacitance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCapacitance.g.cs
@@ -457,7 +457,7 @@ public static ElectricCapacitanceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricCapacitanceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricCapacitanceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricCapacitanceUnit)"/>
@@ -478,7 +478,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCapa
         /// <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 ElectricCapacitanceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricCapacitanceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
index 13300c172c..fcf9311194 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
@@ -526,7 +526,7 @@ public static ElectricChargeUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricChargeUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricChargeUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricChargeUnit)"/>
@@ -547,7 +547,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricChar
         /// <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 ElectricChargeUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricChargeUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
index b80f4482d0..32461bd3f7 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
@@ -361,7 +361,7 @@ public static ElectricChargeDensityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricChargeDensityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricChargeDensityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricChargeDensityUnit)"/>
@@ -382,7 +382,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricChar
         /// <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 ElectricChargeDensityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricChargeDensityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
index 67ed857b98..fae21dd1fa 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
@@ -601,7 +601,7 @@ public static ElectricConductanceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricConductanceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricConductanceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricConductanceUnit)"/>
@@ -622,7 +622,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCond
         /// <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 ElectricConductanceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricConductanceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
index 528070f486..5fed8c31e8 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
@@ -441,7 +441,7 @@ public static ElectricConductivityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricConductivityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricConductivityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricConductivityUnit)"/>
@@ -462,7 +462,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCond
         /// <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 ElectricConductivityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricConductivityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
index 637605c6d2..4200e06c35 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
@@ -496,7 +496,7 @@ public static ElectricCurrentUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricCurrentUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricCurrentUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricCurrentUnit)"/>
@@ -517,7 +517,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCurr
         /// <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 ElectricCurrentUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricCurrentUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
index 3515d52d93..ecfd0d16ae 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
@@ -393,7 +393,7 @@ public static ElectricCurrentDensityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricCurrentDensityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricCurrentDensityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricCurrentDensityUnit)"/>
@@ -414,7 +414,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCurr
         /// <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 ElectricCurrentDensityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricCurrentDensityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
index c2601bedbe..d04ae5f314 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
@@ -457,7 +457,7 @@ public static ElectricCurrentGradientUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricCurrentGradientUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricCurrentGradientUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricCurrentGradientUnit)"/>
@@ -478,7 +478,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCurr
         /// <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 ElectricCurrentGradientUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricCurrentGradientUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
index 7a0282e459..ee2521842d 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
@@ -361,7 +361,7 @@ public static ElectricFieldUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricFieldUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricFieldUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricFieldUnit)"/>
@@ -382,7 +382,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricFiel
         /// <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 ElectricFieldUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricFieldUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricImpedance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricImpedance.g.cs
index 49a4f5531b..2644077589 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricImpedance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricImpedance.g.cs
@@ -474,7 +474,7 @@ public static ElectricImpedanceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricImpedanceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricImpedanceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricImpedanceUnit)"/>
@@ -495,7 +495,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricImpe
         /// <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 ElectricImpedanceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricImpedanceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
index 72b452c4ac..d097a7c27d 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
@@ -425,7 +425,7 @@ public static ElectricInductanceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricInductanceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricInductanceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricInductanceUnit)"/>
@@ -446,7 +446,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricIndu
         /// <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 ElectricInductanceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricInductanceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
index 8e16e66487..704e694ad5 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
@@ -447,7 +447,7 @@ public static ElectricPotentialUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricPotentialUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricPotentialUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricPotentialUnit)"/>
@@ -468,7 +468,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricPote
         /// <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 ElectricPotentialUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricPotentialUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
index 691a696708..9d5d4f89a2 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
@@ -662,7 +662,7 @@ public static ElectricPotentialChangeRateUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricPotentialChangeRateUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricPotentialChangeRateUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricPotentialChangeRateUnit)"/>
@@ -683,7 +683,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricPote
         /// <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 ElectricPotentialChangeRateUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricPotentialChangeRateUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricReactance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricReactance.g.cs
index 246fa5283e..c0f878043e 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricReactance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricReactance.g.cs
@@ -473,7 +473,7 @@ public static ElectricReactanceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricReactanceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricReactanceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricReactanceUnit)"/>
@@ -494,7 +494,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricReac
         /// <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 ElectricReactanceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricReactanceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricReactiveEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricReactiveEnergy.g.cs
index 1e6ce1b120..23b1548394 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricReactiveEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricReactiveEnergy.g.cs
@@ -390,7 +390,7 @@ public static ElectricReactiveEnergyUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricReactiveEnergyUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricReactiveEnergyUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricReactiveEnergyUnit)"/>
@@ -411,7 +411,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricReac
         /// <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 ElectricReactiveEnergyUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricReactiveEnergyUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricReactivePower.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricReactivePower.g.cs
index d16c1b0288..f099e10cab 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricReactivePower.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricReactivePower.g.cs
@@ -409,7 +409,7 @@ public static ElectricReactivePowerUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricReactivePowerUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricReactivePowerUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricReactivePowerUnit)"/>
@@ -430,7 +430,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricReac
         /// <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 ElectricReactivePowerUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricReactivePowerUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
index 3b475ee618..4653677919 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
@@ -476,7 +476,7 @@ public static ElectricResistanceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricResistanceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricResistanceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricResistanceUnit)"/>
@@ -497,7 +497,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricResi
         /// <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 ElectricResistanceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricResistanceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
index 4591efd124..72581feb7a 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
@@ -569,7 +569,7 @@ public static ElectricResistivityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricResistivityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricResistivityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricResistivityUnit)"/>
@@ -590,7 +590,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricResi
         /// <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 ElectricResistivityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricResistivityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
index cf35e233e7..4adad40dd3 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
@@ -393,7 +393,7 @@ public static ElectricSurfaceChargeDensityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricSurfaceChargeDensityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricSurfaceChargeDensityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricSurfaceChargeDensityUnit)"/>
@@ -414,7 +414,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricSurf
         /// <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 ElectricSurfaceChargeDensityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricSurfaceChargeDensityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricSusceptance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricSusceptance.g.cs
index b7962e73d2..3529c1f7b6 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricSusceptance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricSusceptance.g.cs
@@ -601,7 +601,7 @@ public static ElectricSusceptanceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ElectricSusceptanceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ElectricSusceptanceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricSusceptanceUnit)"/>
@@ -622,7 +622,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricSusc
         /// <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 ElectricSusceptanceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ElectricSusceptanceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
index ee650dd3b1..a113b3d5d2 100644
--- a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
@@ -997,7 +997,7 @@ public static EnergyUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static EnergyUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<EnergyUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.EnergyUnit)"/>
@@ -1018,7 +1018,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out EnergyUnit u
         /// <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 EnergyUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<EnergyUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs
index c1b7ba7714..e1bec3211c 100644
--- a/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs
@@ -537,7 +537,7 @@ public static EnergyDensityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static EnergyDensityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<EnergyDensityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.EnergyDensityUnit)"/>
@@ -558,7 +558,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out EnergyDensit
         /// <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 EnergyDensityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<EnergyDensityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
index 2fb78647f0..8cc1205289 100644
--- a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
@@ -459,7 +459,7 @@ public static EntropyUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static EntropyUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<EntropyUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.EntropyUnit)"/>
@@ -480,7 +480,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out EntropyUnit
         /// <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 EntropyUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<EntropyUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/FluidResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/FluidResistance.g.cs
index c5b1913563..e13f9b8e3b 100644
--- a/UnitsNet/GeneratedCode/Quantities/FluidResistance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/FluidResistance.g.cs
@@ -649,7 +649,7 @@ public static FluidResistanceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static FluidResistanceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<FluidResistanceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.FluidResistanceUnit)"/>
@@ -670,7 +670,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out FluidResista
         /// <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 FluidResistanceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<FluidResistanceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Force.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
index 19e96dc347..0d0f2a152b 100644
--- a/UnitsNet/GeneratedCode/Quantities/Force.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
@@ -596,7 +596,7 @@ public static ForceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ForceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ForceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ForceUnit)"/>
@@ -617,7 +617,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ForceUnit un
         /// <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 ForceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ForceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
index 3d2948e876..85efde80b2 100644
--- a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
@@ -585,7 +585,7 @@ public static ForceChangeRateUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ForceChangeRateUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ForceChangeRateUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ForceChangeRateUnit)"/>
@@ -606,7 +606,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ForceChangeR
         /// <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 ForceChangeRateUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ForceChangeRateUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
index 5c4934c44c..d1de5aa977 100644
--- a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
@@ -961,7 +961,7 @@ public static ForcePerLengthUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ForcePerLengthUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ForcePerLengthUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ForcePerLengthUnit)"/>
@@ -982,7 +982,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ForcePerLeng
         /// <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 ForcePerLengthUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ForcePerLengthUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
index 1e426e232b..aeb1055652 100644
--- a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
@@ -537,7 +537,7 @@ public static FrequencyUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static FrequencyUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<FrequencyUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.FrequencyUnit)"/>
@@ -558,7 +558,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out FrequencyUni
         /// <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 FrequencyUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<FrequencyUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
index 0532819357..afe38fcdc0 100644
--- a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
@@ -409,7 +409,7 @@ public static FuelEfficiencyUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static FuelEfficiencyUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<FuelEfficiencyUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.FuelEfficiencyUnit)"/>
@@ -430,7 +430,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out FuelEfficien
         /// <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 FuelEfficiencyUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<FuelEfficiencyUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
index 9865e36c85..c77e2665c0 100644
--- a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
@@ -633,7 +633,7 @@ public static HeatFluxUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static HeatFluxUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<HeatFluxUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.HeatFluxUnit)"/>
@@ -654,7 +654,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out HeatFluxUnit
         /// <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 HeatFluxUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<HeatFluxUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
index fb4ebf6926..fdd3c49adb 100644
--- a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
@@ -422,7 +422,7 @@ public static HeatTransferCoefficientUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static HeatTransferCoefficientUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<HeatTransferCoefficientUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.HeatTransferCoefficientUnit)"/>
@@ -443,7 +443,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out HeatTransfer
         /// <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 HeatTransferCoefficientUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<HeatTransferCoefficientUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
index 1a04548857..23c4ea1003 100644
--- a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
@@ -412,7 +412,7 @@ public static IlluminanceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static IlluminanceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<IlluminanceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.IlluminanceUnit)"/>
@@ -433,7 +433,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out IlluminanceU
         /// <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 IlluminanceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<IlluminanceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs b/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs
index a56c939e48..5c41946c9f 100644
--- a/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs
@@ -550,7 +550,7 @@ public static ImpulseUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ImpulseUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ImpulseUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ImpulseUnit)"/>
@@ -571,7 +571,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ImpulseUnit
         /// <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 ImpulseUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ImpulseUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Information.g.cs b/UnitsNet/GeneratedCode/Quantities/Information.g.cs
index bca77601ae..0033b75cef 100644
--- a/UnitsNet/GeneratedCode/Quantities/Information.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Information.g.cs
@@ -744,7 +744,7 @@ public static InformationUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static InformationUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<InformationUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.InformationUnit)"/>
@@ -765,7 +765,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out InformationU
         /// <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 InformationUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<InformationUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
index 99279811f4..db202c4fc7 100644
--- a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
@@ -566,7 +566,7 @@ public static IrradianceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static IrradianceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<IrradianceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.IrradianceUnit)"/>
@@ -587,7 +587,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out IrradianceUn
         /// <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 IrradianceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<IrradianceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
index 09e764f34d..c751455f3e 100644
--- a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
@@ -489,7 +489,7 @@ public static IrradiationUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static IrradiationUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<IrradiationUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.IrradiationUnit)"/>
@@ -510,7 +510,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out IrradiationU
         /// <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 IrradiationUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<IrradiationUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs b/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs
index 24b2653260..26c3c5ec49 100644
--- a/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs
@@ -521,7 +521,7 @@ public static JerkUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static JerkUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<JerkUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.JerkUnit)"/>
@@ -542,7 +542,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out JerkUnit uni
         /// <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 JerkUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<JerkUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
index a1b8edc5a9..6b0ab18495 100644
--- a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
@@ -495,7 +495,7 @@ public static KinematicViscosityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static KinematicViscosityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<KinematicViscosityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.KinematicViscosityUnit)"/>
@@ -516,7 +516,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out KinematicVis
         /// <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 KinematicViscosityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<KinematicViscosityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs b/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs
index 8cf019115c..df75016505 100644
--- a/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs
@@ -393,7 +393,7 @@ public static LeakRateUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static LeakRateUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<LeakRateUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LeakRateUnit)"/>
@@ -414,7 +414,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LeakRateUnit
         /// <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 LeakRateUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<LeakRateUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Length.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
index 114cd08a40..9b840b9345 100644
--- a/UnitsNet/GeneratedCode/Quantities/Length.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
@@ -1034,7 +1034,7 @@ public static LengthUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static LengthUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<LengthUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LengthUnit)"/>
@@ -1055,7 +1055,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LengthUnit u
         /// <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 LengthUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<LengthUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Level.g.cs b/UnitsNet/GeneratedCode/Quantities/Level.g.cs
index a3471b0356..b3164608d9 100644
--- a/UnitsNet/GeneratedCode/Quantities/Level.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Level.g.cs
@@ -360,7 +360,7 @@ public static LevelUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static LevelUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<LevelUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LevelUnit)"/>
@@ -381,7 +381,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LevelUnit un
         /// <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 LevelUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<LevelUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
index 14badeb281..b4331da451 100644
--- a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
@@ -638,7 +638,7 @@ public static LinearDensityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static LinearDensityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<LinearDensityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LinearDensityUnit)"/>
@@ -659,7 +659,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LinearDensit
         /// <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 LinearDensityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<LinearDensityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
index 67279ce157..ba75d89525 100644
--- a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
@@ -745,7 +745,7 @@ public static LinearPowerDensityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static LinearPowerDensityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<LinearPowerDensityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LinearPowerDensityUnit)"/>
@@ -766,7 +766,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LinearPowerD
         /// <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 LinearPowerDensityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<LinearPowerDensityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs b/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs
index f4337dcb1f..8ffd9ce7bd 100644
--- a/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs
@@ -508,7 +508,7 @@ public static LuminanceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static LuminanceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<LuminanceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LuminanceUnit)"/>
@@ -529,7 +529,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LuminanceUni
         /// <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 LuminanceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<LuminanceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
index 1ad38df36f..4605d714e9 100644
--- a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
@@ -569,7 +569,7 @@ public static LuminosityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static LuminosityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<LuminosityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LuminosityUnit)"/>
@@ -590,7 +590,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LuminosityUn
         /// <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 LuminosityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<LuminosityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
index f7db868075..768a1f401c 100644
--- a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
@@ -365,7 +365,7 @@ public static LuminousFluxUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static LuminousFluxUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<LuminousFluxUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LuminousFluxUnit)"/>
@@ -386,7 +386,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LuminousFlux
         /// <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 LuminousFluxUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<LuminousFluxUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
index 7e2d128ea3..3b67fb319c 100644
--- a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
@@ -365,7 +365,7 @@ public static LuminousIntensityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static LuminousIntensityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<LuminousIntensityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LuminousIntensityUnit)"/>
@@ -386,7 +386,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LuminousInte
         /// <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 LuminousIntensityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<LuminousIntensityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
index cf5eff0f76..9785936997 100644
--- a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
@@ -441,7 +441,7 @@ public static MagneticFieldUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MagneticFieldUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MagneticFieldUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MagneticFieldUnit)"/>
@@ -462,7 +462,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MagneticFiel
         /// <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 MagneticFieldUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MagneticFieldUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
index 308eb4923c..5dad87e062 100644
--- a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
@@ -361,7 +361,7 @@ public static MagneticFluxUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MagneticFluxUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MagneticFluxUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MagneticFluxUnit)"/>
@@ -382,7 +382,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MagneticFlux
         /// <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 MagneticFluxUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MagneticFluxUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
index 6497d0312e..eea23408fc 100644
--- a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
@@ -361,7 +361,7 @@ public static MagnetizationUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MagnetizationUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MagnetizationUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MagnetizationUnit)"/>
@@ -382,7 +382,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out Magnetizatio
         /// <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 MagnetizationUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MagnetizationUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
index f53a806f6b..5ae032fd8a 100644
--- a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
@@ -792,7 +792,7 @@ public static MassUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MassUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MassUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MassUnit)"/>
@@ -813,7 +813,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassUnit uni
         /// <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 MassUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MassUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
index 97d2cee9f9..28553b5ac2 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
@@ -1136,7 +1136,7 @@ public static MassConcentrationUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MassConcentrationUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MassConcentrationUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MassConcentrationUnit)"/>
@@ -1157,7 +1157,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassConcentr
         /// <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 MassConcentrationUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MassConcentrationUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
index 7a3afff7ed..691f154899 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
@@ -882,7 +882,7 @@ public static MassFlowUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MassFlowUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MassFlowUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MassFlowUnit)"/>
@@ -903,7 +903,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassFlowUnit
         /// <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 MassFlowUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MassFlowUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
index eb5fcc27cc..13c4785614 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
@@ -539,7 +539,7 @@ public static MassFluxUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MassFluxUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MassFluxUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MassFluxUnit)"/>
@@ -560,7 +560,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassFluxUnit
         /// <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 MassFluxUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MassFluxUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
index d8992b1464..292dea365a 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
@@ -718,7 +718,7 @@ public static MassFractionUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MassFractionUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MassFractionUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MassFractionUnit)"/>
@@ -739,7 +739,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassFraction
         /// <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 MassFractionUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MassFractionUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
index d1c6c45b8b..ef31ce4910 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
@@ -790,7 +790,7 @@ public static MassMomentOfInertiaUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MassMomentOfInertiaUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MassMomentOfInertiaUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MassMomentOfInertiaUnit)"/>
@@ -811,7 +811,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassMomentOf
         /// <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 MassMomentOfInertiaUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MassMomentOfInertiaUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Molality.g.cs b/UnitsNet/GeneratedCode/Quantities/Molality.g.cs
index 1b1f031ebd..0852ab116d 100644
--- a/UnitsNet/GeneratedCode/Quantities/Molality.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Molality.g.cs
@@ -393,7 +393,7 @@ public static MolalityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MolalityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MolalityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MolalityUnit)"/>
@@ -414,7 +414,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolalityUnit
         /// <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 MolalityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MolalityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
index b0a2ccea3a..6bc85de07f 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
@@ -393,7 +393,7 @@ public static MolarEnergyUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MolarEnergyUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MolarEnergyUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MolarEnergyUnit)"/>
@@ -414,7 +414,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarEnergyU
         /// <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 MolarEnergyUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MolarEnergyUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
index b73d38497f..ce8bd5ca63 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
@@ -390,7 +390,7 @@ public static MolarEntropyUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MolarEntropyUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MolarEntropyUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MolarEntropyUnit)"/>
@@ -411,7 +411,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarEntropy
         /// <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 MolarEntropyUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MolarEntropyUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs
index 6e9b728f67..b790af968f 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs
@@ -492,7 +492,7 @@ public static MolarFlowUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MolarFlowUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MolarFlowUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MolarFlowUnit)"/>
@@ -513,7 +513,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarFlowUni
         /// <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 MolarFlowUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MolarFlowUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
index ed8423a77b..1de6752f8a 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
@@ -555,7 +555,7 @@ public static MolarMassUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MolarMassUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MolarMassUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MolarMassUnit)"/>
@@ -576,7 +576,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarMassUni
         /// <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 MolarMassUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MolarMassUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
index 09ea4ce616..c76a4000cc 100644
--- a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
@@ -528,7 +528,7 @@ public static MolarityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static MolarityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<MolarityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MolarityUnit)"/>
@@ -549,7 +549,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarityUnit
         /// <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 MolarityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<MolarityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
index 5c7f960069..762d30c17e 100644
--- a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
@@ -361,7 +361,7 @@ public static PermeabilityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static PermeabilityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<PermeabilityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PermeabilityUnit)"/>
@@ -382,7 +382,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out Permeability
         /// <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 PermeabilityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<PermeabilityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
index 4383a6ed83..0e9915ba01 100644
--- a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
@@ -361,7 +361,7 @@ public static PermittivityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static PermittivityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<PermittivityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PermittivityUnit)"/>
@@ -382,7 +382,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out Permittivity
         /// <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 PermittivityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<PermittivityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs b/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
index f17e84f4e8..4ecf3121cd 100644
--- a/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
@@ -425,7 +425,7 @@ public static PorousMediumPermeabilityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static PorousMediumPermeabilityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<PorousMediumPermeabilityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PorousMediumPermeabilityUnit)"/>
@@ -446,7 +446,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out PorousMedium
         /// <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 PorousMediumPermeabilityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<PorousMediumPermeabilityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Power.g.cs b/UnitsNet/GeneratedCode/Quantities/Power.g.cs
index 6c8b2cb6a7..a53371d398 100644
--- a/UnitsNet/GeneratedCode/Quantities/Power.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Power.g.cs
@@ -790,7 +790,7 @@ public static PowerUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static PowerUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<PowerUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PowerUnit)"/>
@@ -811,7 +811,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out PowerUnit un
         /// <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 PowerUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<PowerUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
index e89c8e059c..d1044e7ab7 100644
--- a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
@@ -1046,7 +1046,7 @@ public static PowerDensityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static PowerDensityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<PowerDensityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PowerDensityUnit)"/>
@@ -1067,7 +1067,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out PowerDensity
         /// <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 PowerDensityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<PowerDensityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
index 1b98d9cf78..2f8ae326ed 100644
--- a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
@@ -360,7 +360,7 @@ public static PowerRatioUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static PowerRatioUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<PowerRatioUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PowerRatioUnit)"/>
@@ -381,7 +381,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out PowerRatioUn
         /// <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 PowerRatioUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<PowerRatioUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
index 94f6297f27..77f62d9f8a 100644
--- a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
@@ -1106,7 +1106,7 @@ public static PressureUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static PressureUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<PressureUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PressureUnit)"/>
@@ -1127,7 +1127,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out PressureUnit
         /// <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 PressureUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<PressureUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
index c8021d851b..506f1d33bc 100644
--- a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
@@ -633,7 +633,7 @@ public static PressureChangeRateUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static PressureChangeRateUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<PressureChangeRateUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PressureChangeRateUnit)"/>
@@ -654,7 +654,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out PressureChan
         /// <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 PressureChangeRateUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<PressureChangeRateUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDose.g.cs b/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDose.g.cs
index 4b9f3943db..5daeba0836 100644
--- a/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDose.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDose.g.cs
@@ -442,7 +442,7 @@ public static RadiationEquivalentDoseUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static RadiationEquivalentDoseUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<RadiationEquivalentDoseUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RadiationEquivalentDoseUnit)"/>
@@ -463,7 +463,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RadiationEqu
         /// <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 RadiationEquivalentDoseUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<RadiationEquivalentDoseUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDoseRate.g.cs b/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDoseRate.g.cs
index 5cd347b7d5..63ade244f2 100644
--- a/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDoseRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDoseRate.g.cs
@@ -505,7 +505,7 @@ public static RadiationEquivalentDoseRateUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static RadiationEquivalentDoseRateUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<RadiationEquivalentDoseRateUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RadiationEquivalentDoseRateUnit)"/>
@@ -526,7 +526,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RadiationEqu
         /// <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 RadiationEquivalentDoseRateUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<RadiationEquivalentDoseRateUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs b/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs
index 8298931338..58ffc14496 100644
--- a/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs
@@ -470,7 +470,7 @@ public static RadiationExposureUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static RadiationExposureUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<RadiationExposureUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RadiationExposureUnit)"/>
@@ -491,7 +491,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RadiationExp
         /// <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 RadiationExposureUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<RadiationExposureUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs b/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs
index 0793e6cae3..b16d0e4ef7 100644
--- a/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs
@@ -806,7 +806,7 @@ public static RadioactivityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static RadioactivityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<RadioactivityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RadioactivityUnit)"/>
@@ -827,7 +827,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out Radioactivit
         /// <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 RadioactivityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<RadioactivityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
index 61d01c71be..eba17e6d45 100644
--- a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
@@ -424,7 +424,7 @@ public static RatioUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static RatioUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<RatioUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RatioUnit)"/>
@@ -445,7 +445,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RatioUnit un
         /// <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 RatioUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<RatioUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
index 28035c2af5..80c9e76869 100644
--- a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
@@ -374,7 +374,7 @@ public static RatioChangeRateUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static RatioChangeRateUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<RatioChangeRateUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RatioChangeRateUnit)"/>
@@ -395,7 +395,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RatioChangeR
         /// <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 RatioChangeRateUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<RatioChangeRateUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
index 5a40259f87..56149eb16a 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
@@ -528,7 +528,7 @@ public static ReciprocalAreaUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ReciprocalAreaUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ReciprocalAreaUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ReciprocalAreaUnit)"/>
@@ -549,7 +549,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ReciprocalAr
         /// <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 ReciprocalAreaUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ReciprocalAreaUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
index 4f611a43ee..22aac13593 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
@@ -514,7 +514,7 @@ public static ReciprocalLengthUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ReciprocalLengthUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ReciprocalLengthUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ReciprocalLengthUnit)"/>
@@ -535,7 +535,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ReciprocalLe
         /// <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 ReciprocalLengthUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ReciprocalLengthUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
index b14795608b..417e1cf5c2 100644
--- a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
@@ -344,7 +344,7 @@ public static RelativeHumidityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static RelativeHumidityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<RelativeHumidityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RelativeHumidityUnit)"/>
@@ -365,7 +365,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RelativeHumi
         /// <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 RelativeHumidityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<RelativeHumidityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
index fd96df6886..21bafa6b0b 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
@@ -406,7 +406,7 @@ public static RotationalAccelerationUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static RotationalAccelerationUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<RotationalAccelerationUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RotationalAccelerationUnit)"/>
@@ -427,7 +427,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RotationalAc
         /// <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 RotationalAccelerationUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<RotationalAccelerationUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
index f4f8770ec3..f6bf1dbc9f 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
@@ -554,7 +554,7 @@ public static RotationalSpeedUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static RotationalSpeedUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<RotationalSpeedUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RotationalSpeedUnit)"/>
@@ -575,7 +575,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RotationalSp
         /// <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 RotationalSpeedUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<RotationalSpeedUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
index 0eae98fef1..28faa55a11 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
@@ -875,7 +875,7 @@ public static RotationalStiffnessUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static RotationalStiffnessUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<RotationalStiffnessUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RotationalStiffnessUnit)"/>
@@ -896,7 +896,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RotationalSt
         /// <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 RotationalStiffnessUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<RotationalStiffnessUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
index 47df1e4037..02a9e23873 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
@@ -425,7 +425,7 @@ public static RotationalStiffnessPerLengthUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static RotationalStiffnessPerLengthUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<RotationalStiffnessPerLengthUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RotationalStiffnessPerLengthUnit)"/>
@@ -446,7 +446,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RotationalSt
         /// <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 RotationalStiffnessPerLengthUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<RotationalStiffnessPerLengthUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs b/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs
index 3c5bdc3153..c2a7638fe1 100644
--- a/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs
@@ -344,7 +344,7 @@ public static ScalarUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ScalarUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ScalarUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ScalarUnit)"/>
@@ -365,7 +365,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ScalarUnit u
         /// <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 ScalarUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ScalarUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
index d9579a9bec..802e665ba0 100644
--- a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
@@ -347,7 +347,7 @@ public static SolidAngleUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static SolidAngleUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<SolidAngleUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SolidAngleUnit)"/>
@@ -368,7 +368,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SolidAngleUn
         /// <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 SolidAngleUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<SolidAngleUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
index 11780f7631..9f666dbe9e 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
@@ -833,7 +833,7 @@ public static SpecificEnergyUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static SpecificEnergyUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<SpecificEnergyUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SpecificEnergyUnit)"/>
@@ -854,7 +854,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificEner
         /// <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 SpecificEnergyUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<SpecificEnergyUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
index 803bb51c14..30f4fad39c 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
@@ -490,7 +490,7 @@ public static SpecificEntropyUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static SpecificEntropyUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<SpecificEntropyUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SpecificEntropyUnit)"/>
@@ -511,7 +511,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificEntr
         /// <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 SpecificEntropyUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<SpecificEntropyUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
index 276f6e83e5..6c2933d879 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
@@ -409,7 +409,7 @@ public static SpecificFuelConsumptionUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static SpecificFuelConsumptionUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<SpecificFuelConsumptionUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SpecificFuelConsumptionUnit)"/>
@@ -430,7 +430,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificFuel
         /// <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 SpecificFuelConsumptionUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<SpecificFuelConsumptionUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
index b65942490f..4acd5cf7e4 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
@@ -393,7 +393,7 @@ public static SpecificVolumeUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static SpecificVolumeUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<SpecificVolumeUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SpecificVolumeUnit)"/>
@@ -414,7 +414,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificVolu
         /// <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 SpecificVolumeUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<SpecificVolumeUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
index ad707ea084..bfe522fa9a 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
@@ -623,7 +623,7 @@ public static SpecificWeightUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static SpecificWeightUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<SpecificWeightUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SpecificWeightUnit)"/>
@@ -644,7 +644,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificWeig
         /// <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 SpecificWeightUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<SpecificWeightUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
index db7c424f76..93eaf1baad 100644
--- a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
@@ -880,7 +880,7 @@ public static SpeedUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static SpeedUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<SpeedUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SpeedUnit)"/>
@@ -901,7 +901,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpeedUnit un
         /// <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 SpeedUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<SpeedUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
index 82a30f53e4..d462f2ec01 100644
--- a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
@@ -486,7 +486,7 @@ public static StandardVolumeFlowUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static StandardVolumeFlowUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<StandardVolumeFlowUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.StandardVolumeFlowUnit)"/>
@@ -507,7 +507,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out StandardVolu
         /// <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 StandardVolumeFlowUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<StandardVolumeFlowUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
index a98def59ea..1bcf9aae1c 100644
--- a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
@@ -499,7 +499,7 @@ public static TemperatureUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static TemperatureUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<TemperatureUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.TemperatureUnit)"/>
@@ -520,7 +520,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out TemperatureU
         /// <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 TemperatureUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<TemperatureUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
index d386589bc4..68ef96ca1a 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
@@ -617,7 +617,7 @@ public static TemperatureChangeRateUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static TemperatureChangeRateUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<TemperatureChangeRateUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.TemperatureChangeRateUnit)"/>
@@ -638,7 +638,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out TemperatureC
         /// <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 TemperatureChangeRateUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<TemperatureChangeRateUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
index 0a02aca388..5331f5dc8c 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
@@ -495,7 +495,7 @@ public static TemperatureDeltaUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static TemperatureDeltaUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<TemperatureDeltaUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.TemperatureDeltaUnit)"/>
@@ -516,7 +516,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out TemperatureD
         /// <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 TemperatureDeltaUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<TemperatureDeltaUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs
index 02afa3cd6f..50015d44f6 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs
@@ -409,7 +409,7 @@ public static TemperatureGradientUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static TemperatureGradientUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<TemperatureGradientUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.TemperatureGradientUnit)"/>
@@ -430,7 +430,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out TemperatureG
         /// <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 TemperatureGradientUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<TemperatureGradientUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
index 5011bf152e..ac9acf1596 100644
--- a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
@@ -377,7 +377,7 @@ public static ThermalConductivityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ThermalConductivityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ThermalConductivityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ThermalConductivityUnit)"/>
@@ -398,7 +398,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ThermalCondu
         /// <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 ThermalConductivityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ThermalConductivityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalInsulance.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalInsulance.g.cs
index 98cb82a981..b29f6ad3f6 100644
--- a/UnitsNet/GeneratedCode/Quantities/ThermalInsulance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ThermalInsulance.g.cs
@@ -438,7 +438,7 @@ public static ThermalInsulanceUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static ThermalInsulanceUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<ThermalInsulanceUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ThermalInsulanceUnit)"/>
@@ -459,7 +459,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ThermalInsul
         /// <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 ThermalInsulanceUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<ThermalInsulanceUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
index 3af689138c..e23c5817f7 100644
--- a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
@@ -751,7 +751,7 @@ public static TorqueUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static TorqueUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<TorqueUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.TorqueUnit)"/>
@@ -772,7 +772,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out TorqueUnit u
         /// <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 TorqueUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<TorqueUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
index e10d096fad..c87d0c355d 100644
--- a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
@@ -347,7 +347,7 @@ public static TurbidityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static TurbidityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<TurbidityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.TurbidityUnit)"/>
@@ -368,7 +368,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out TurbidityUni
         /// <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 TurbidityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<TurbidityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
index ef2c7139da..8b3890ab3a 100644
--- a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
@@ -344,7 +344,7 @@ public static VitaminAUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static VitaminAUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<VitaminAUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VitaminAUnit)"/>
@@ -365,7 +365,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VitaminAUnit
         /// <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 VitaminAUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<VitaminAUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
index 25cb6f7120..8d052f7ce0 100644
--- a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
@@ -1221,7 +1221,7 @@ public static VolumeUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static VolumeUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<VolumeUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VolumeUnit)"/>
@@ -1242,7 +1242,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumeUnit u
         /// <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 VolumeUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<VolumeUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
index 6a598defda..9a7fa86140 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
@@ -655,7 +655,7 @@ public static VolumeConcentrationUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static VolumeConcentrationUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<VolumeConcentrationUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VolumeConcentrationUnit)"/>
@@ -676,7 +676,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumeConcen
         /// <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 VolumeConcentrationUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<VolumeConcentrationUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
index 24304ed034..8175223c95 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
@@ -1549,7 +1549,7 @@ public static VolumeFlowUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static VolumeFlowUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<VolumeFlowUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VolumeFlowUnit)"/>
@@ -1570,7 +1570,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumeFlowUn
         /// <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 VolumeFlowUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<VolumeFlowUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
index 1ef2505bec..16b6817385 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
@@ -374,7 +374,7 @@ public static VolumeFlowPerAreaUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static VolumeFlowPerAreaUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<VolumeFlowPerAreaUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VolumeFlowPerAreaUnit)"/>
@@ -395,7 +395,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumeFlowPe
         /// <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 VolumeFlowPerAreaUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<VolumeFlowPerAreaUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
index 3b7859334d..834dd7742e 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
@@ -486,7 +486,7 @@ public static VolumePerLengthUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static VolumePerLengthUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<VolumePerLengthUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VolumePerLengthUnit)"/>
@@ -507,7 +507,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumePerLen
         /// <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 VolumePerLengthUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<VolumePerLengthUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
index f7c82f84b4..f21cc6d14a 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
@@ -489,7 +489,7 @@ public static VolumetricHeatCapacityUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static VolumetricHeatCapacityUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<VolumetricHeatCapacityUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VolumetricHeatCapacityUnit)"/>
@@ -510,7 +510,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumetricHe
         /// <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 VolumetricHeatCapacityUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<VolumetricHeatCapacityUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion
diff --git a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
index 990b5b876a..ead0a8657c 100644
--- a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
@@ -438,7 +438,7 @@ public static WarpingMomentOfInertiaUnit ParseUnit(string str)
         /// <exception cref="UnitsNetException">Error parsing string.</exception>
         public static WarpingMomentOfInertiaUnit ParseUnit(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.UnitParser.Parse<WarpingMomentOfInertiaUnit>(str, provider);
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
         /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.WarpingMomentOfInertiaUnit)"/>
@@ -459,7 +459,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out WarpingMomen
         /// <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 WarpingMomentOfInertiaUnit unit)
         {
-            return UnitsNetSetup.Default.UnitParser.TryParse<WarpingMomentOfInertiaUnit>(str, provider, out unit);
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
         }
 
         #endregion

From f9a2766b959334432c531c44afca207f37c155cc Mon Sep 17 00:00:00 2001
From: lipchev <lipchev@gmail.com>
Date: Sat, 19 Apr 2025 02:28:03 +0300
Subject: [PATCH 2/3] - UnitAbbreviationsCache: removed the obsolete method and
 replaced the return types to IReadOnlyList - UnitParser: refactored the
 common parts of the GetUnitFromAbbreviation code - completed the test
 coverage for the UnitParser and the UnitAbbreviationsCache

---
 UnitsNet.Tests/UnitAbbreviationsCacheTests.cs | 139 +++++++++++++--
 UnitsNet.Tests/UnitParserTests.cs             | 110 +++++++++++-
 UnitsNet/CustomCode/UnitAbbreviationsCache.cs |  33 +---
 UnitsNet/CustomCode/UnitParser.cs             | 166 ++++++++----------
 UnitsNet/QuantityFormatter.cs                 |   4 +-
 5 files changed, 299 insertions(+), 153 deletions(-)

diff --git a/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs b/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs
index 41ccea2340..aa0bae8fad 100644
--- a/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs
+++ b/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs
@@ -17,9 +17,40 @@ public class UnitAbbreviationsCacheTests
     {
         private static readonly CultureInfo AmericanCulture = CultureInfo.GetCultureInfo("en-US");
         private static readonly CultureInfo NorwegianCulture = CultureInfo.GetCultureInfo("nb-NO");
+
+        [Fact]
+        public void EmptyConstructor_ReturnsAnAbbreviationCacheWithDefaultQuantityInfoLookup()
+        {
+            var unitAbbreviationCache = new UnitAbbreviationsCache();
+
+            Assert.Equal(UnitsNetSetup.Default.QuantityInfoLookup, unitAbbreviationCache.Quantities);
+            Assert.Equal("g", unitAbbreviationCache.GetUnitAbbreviations(MassUnit.Gram, AmericanCulture)[0]);
+            Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.GetUnitAbbreviations(HowMuchUnit.Some));
+        }
         
         [Fact]
-        public void UnitAbbreviationsCacheDefaultReturnsUnitsNetSetupDefaultUnitAbbreviations()
+        public void Constructor_WithQuantities_ReturnsAnAbbreviationCacheWithNewQuantityInfoLookup()
+        {
+            var unitAbbreviationCache = new UnitAbbreviationsCache([Mass.Info, HowMuch.Info]);
+
+            Assert.NotEqual(UnitsNetSetup.Default.QuantityInfoLookup, unitAbbreviationCache.Quantities);
+            Assert.Equal("g", unitAbbreviationCache.GetUnitAbbreviations(MassUnit.Gram, AmericanCulture)[0]);
+            Assert.Empty(unitAbbreviationCache.GetUnitAbbreviations(HowMuchUnit.Some, AmericanCulture));
+            Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.GetUnitAbbreviations(LengthUnit.Meter));
+        }
+        
+        [Fact]
+        public void CreateDefault_ReturnsAnAbbreviationCacheWithDefaultQuantityInfoLookup()
+        {
+            var unitAbbreviationCache = UnitAbbreviationsCache.CreateDefault();
+
+            Assert.Equal(UnitsNetSetup.Default.QuantityInfoLookup, unitAbbreviationCache.Quantities);
+            Assert.Equal("g", unitAbbreviationCache.GetUnitAbbreviations(MassUnit.Gram, AmericanCulture)[0]);
+            Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.GetUnitAbbreviations(HowMuchUnit.Some));
+        }
+
+        [Fact]
+        public void UnitAbbreviationsCache_Default_ReturnsInstanceFromUnitsNetSetup()
         {
             Assert.Equal(UnitsNetSetup.Default.UnitAbbreviations, UnitAbbreviationsCache.Default);
         }
@@ -34,7 +65,7 @@ public void GetUnitAbbreviationsThrowsUnitNotFoundExceptionIfNoneExist()
         }
 
         [Fact]
-        public void GetUnitAbbreviationsReturnsTheExpectedAbbreviationWhenConstructedWithTheSpecificQuantityInfo()
+        public void GetUnitAbbreviationReturnsTheExpectedAbbreviationWhenConstructedWithTheSpecificQuantityInfo()
         {
             Assert.Multiple(checks:
             [
@@ -43,6 +74,13 @@ public void GetUnitAbbreviationsReturnsTheExpectedAbbreviationWhenConstructedWit
             ]);
         }
 
+        [Fact]
+        public void GetUnitAbbreviationsReturnsTheExpectedAbbreviationWhenConstructedWithTheSpecificQuantityInfo()
+        {
+            var unitAbbreviationCache = new UnitAbbreviationsCache([Mass.Info]);
+            Assert.Equal("g", unitAbbreviationCache.GetUnitAbbreviations(MassUnit.Gram, AmericanCulture)[0]);
+        }
+
         [Fact]
         public void GetDefaultAbbreviationReturnsTheExpectedAbbreviationWhenConstructedWithTheSpecificQuantityInfo()
         {
@@ -71,6 +109,24 @@ public void GetDefaultAbbreviationFallsBackToUsEnglishCulture()
             Assert.Equal("US english abbreviation for Unit1", abbreviation);
         }
 
+        [Fact]
+        public void GetDefaultAbbreviationFallsBackToInvariantCulture()
+        {
+            // CurrentCulture affects number formatting, such as comma or dot as decimal separator.
+            // CurrentCulture also affects localization of unit abbreviations.
+            // Zulu (South Africa)
+            var zuluCulture = CultureInfo.GetCultureInfo("zu-ZA");
+
+            var abbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
+            abbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.AShitTon, CultureInfo.InvariantCulture, "Invariant abbreviation for Unit1");
+
+            // Act
+            string abbreviation = abbreviationsCache.GetDefaultAbbreviation(HowMuchUnit.AShitTon, zuluCulture);
+
+            // Assert
+            Assert.Equal("Invariant abbreviation for Unit1", abbreviation);
+        }
+
         [Fact]
         public void GetDefaultAbbreviationThrowsUnitNotFoundExceptionIfNoneExist()
         {
@@ -87,9 +143,22 @@ public void GetDefaultAbbreviation_ForUnitWithoutAbbreviations_ThrowsInvalidOper
         }
 
         [Fact]
-        public void GetAbbreviationsThrowsArgumentNullExceptionWhenGivenANullUnitInfo()
+        public void GetAllUnitAbbreviationsForQuantity_WithQuantityWithoutAbbreviations_ReturnsEmpty()
+        {
+            var unitAbbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
+            Assert.Empty(unitAbbreviationsCache.GetAllUnitAbbreviationsForQuantity(typeof(HowMuchUnit)));
+        }
+
+        [Fact]
+        public void GetAllUnitAbbreviationsForQuantity_WithInvalidUnitType_ThrowsArgumentException()
+        {
+            Assert.Throws<ArgumentException>(() => UnitAbbreviationsCache.Default.GetAllUnitAbbreviationsForQuantity(typeof(DateTime)));
+        }
+
+        [Fact]
+        public void GetAllUnitAbbreviationsForQuantity_WithUnknownUnitType_ThrowsUnitNotFoundException()
         {
-            Assert.Throws<ArgumentNullException>(() => new UnitAbbreviationsCache().GetAbbreviations(null!));
+            Assert.Throws<UnitNotFoundException>(() => UnitAbbreviationsCache.Default.GetAllUnitAbbreviationsForQuantity(typeof(HowMuchUnit)));
         }
 
         [Fact]
@@ -119,15 +188,6 @@ public void MapUnitToAbbreviation_AddCustomUnit_DoesNotOverrideDefaultAbbreviati
             Assert.Equal("m²", cache.GetDefaultAbbreviation(AreaUnit.SquareMeter, AmericanCulture));
         }
 
-        [Fact]
-        public void MapUnitToDefaultAbbreviation_GivenUnitAndCulture_SetsDefaultAbbreviationForUnitAndCulture()
-        {
-            var cache = new UnitAbbreviationsCache();
-            cache.MapUnitToDefaultAbbreviation(AreaUnit.SquareMeter, AmericanCulture, "m^2");
-
-            Assert.Equal("m^2", cache.GetDefaultAbbreviation(AreaUnit.SquareMeter, AmericanCulture));
-        }
-
         [Fact]
         public void MapUnitToDefaultAbbreviation_GivenUnitAndNoCulture_SetsDefaultAbbreviationForUnitForCurrentCulture()
         {
@@ -141,15 +201,21 @@ public void MapUnitToDefaultAbbreviation_GivenUnitAndNoCulture_SetsDefaultAbbrev
         }
 
         [Fact]
-        public void MapUnitToDefaultAbbreviation_GivenUnitTypeAndValue_SetsDefaultAbbreviationForUnitForCurrentCulture()
+        public void MapUnitToDefaultAbbreviation_GivenUnitAndCulture_SetsDefaultAbbreviationForUnitAndCulture()
         {
-            using var cultureScope = new CultureScope(NorwegianCulture);
-            var cache = new UnitAbbreviationsCache([Mass.Info]);
+            var cache = new UnitAbbreviationsCache([Area.Info]);
+            cache.MapUnitToDefaultAbbreviation(AreaUnit.SquareMeter, AmericanCulture, "m^2");
 
-            cache.MapUnitToDefaultAbbreviation(typeof(MassUnit), (int)MassUnit.Gram, null, "zz");
+            Assert.Equal("m^2", cache.GetDefaultAbbreviation(AreaUnit.SquareMeter, AmericanCulture));
+        }
 
-            Assert.Equal("zz", cache.GetDefaultAbbreviation(MassUnit.Gram));
-            Assert.Equal("g", cache.GetDefaultAbbreviation(MassUnit.Gram, AmericanCulture));
+        [Fact]
+        public void MapUnitToDefaultAbbreviation_GivenUnitTypeValueAndCulture_SetsDefaultAbbreviationForUnitAndCulture()
+        {
+            var cache = new UnitAbbreviationsCache([Area.Info]);
+            cache.MapUnitToDefaultAbbreviation(typeof(AreaUnit), (int)AreaUnit.SquareMeter, AmericanCulture, "m^2");
+
+            Assert.Equal("m^2", cache.GetDefaultAbbreviation(AreaUnit.SquareMeter, AmericanCulture));
         }
 
         [Fact]
@@ -214,5 +280,40 @@ public void MapAndLookup_WithSpecificEnumType()
             unitAbbreviationsCache.MapUnitToDefaultAbbreviation(HowMuchUnit.Some, "sm");
             Assert.Equal("sm", unitAbbreviationsCache.GetDefaultAbbreviation(HowMuchUnit.Some));
         }
+
+        /// <inheritdoc cref="MapAndLookup_WithSpecificEnumType"/>
+        [Fact]
+        public void MapAndLookup_WithEnumType()
+        {
+            Enum valueAsEnumType = HowMuchUnit.Some;
+            var unitAbbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
+            unitAbbreviationsCache.MapUnitToDefaultAbbreviation(valueAsEnumType, "sm");
+            Assert.Equal("sm", unitAbbreviationsCache.GetDefaultAbbreviation(valueAsEnumType));
+        }
+
+        /// <inheritdoc cref="MapAndLookup_WithSpecificEnumType"/>
+        [Fact]
+        public void MapAndLookup_MapWithSpecificEnumType_LookupWithEnumType()
+        {
+            var unitAbbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
+            unitAbbreviationsCache.MapUnitToDefaultAbbreviation(HowMuchUnit.Some, "sm");
+            Assert.Equal("sm", unitAbbreviationsCache.GetDefaultAbbreviation((Enum)HowMuchUnit.Some));
+        }
+        
+        [Fact]
+        public void MapUnitToAbbreviation_WithUnknownUnit_ThrowsUnitNotFoundException()
+        {
+            var unitAbbreviationCache = new UnitAbbreviationsCache([Mass.Info]);
+            Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.MapUnitToAbbreviation(HowMuchUnit.Some, "nothing"));
+            Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.MapUnitToAbbreviation(LengthUnit.Centimeter, "nothing"));
+        }
+
+        [Fact]
+        public void MapUnitToDefaultAbbreviation_WithUnknownUnit_ThrowsUnitNotFoundException()
+        {
+            var unitAbbreviationCache = new UnitAbbreviationsCache([Mass.Info]);
+            Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.MapUnitToDefaultAbbreviation(HowMuchUnit.Some, "nothing"));
+            Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.MapUnitToDefaultAbbreviation(LengthUnit.AstronomicalUnit, "nothing"));
+        }
     }
 }
diff --git a/UnitsNet.Tests/UnitParserTests.cs b/UnitsNet.Tests/UnitParserTests.cs
index fc1edf2df9..63131e4483 100644
--- a/UnitsNet.Tests/UnitParserTests.cs
+++ b/UnitsNet.Tests/UnitParserTests.cs
@@ -11,12 +11,40 @@ namespace UnitsNet.Tests
 {
     public class UnitParserTests
     {
+        [Fact]
+        public void Constructor_WithQuantitiesCreatesNewAbbreviationsCacheAndNewQuantityInfoLookup()
+        {
+            var unitParser = new UnitParser([Mass.Info]);
+            Assert.NotNull(unitParser.Abbreviations);
+            Assert.NotEqual(UnitAbbreviationsCache.Default, unitParser.Abbreviations);
+            Assert.NotEqual(UnitsNetSetup.Default.QuantityInfoLookup, unitParser.Quantities);
+        }
+        
+        [Fact]
+        public void Constructor_WithQuantityInfoLookupCreatesNewAbbreviationsCache()
+        {
+            var quantities = new QuantityInfoLookup([Mass.Info]);
+            var unitParser = new UnitParser(quantities);
+            Assert.NotNull(unitParser.Abbreviations);
+            Assert.NotEqual(UnitAbbreviationsCache.Default, unitParser.Abbreviations);
+            Assert.Equal(quantities, unitParser.Quantities);
+        }
+        
+        [Fact]
+        public void CreateDefault_CreatesNewAbbreviationsCacheWithDefaultQuantities()
+        {
+            var unitParser = UnitParser.CreateDefault();
+            Assert.NotNull(unitParser.Abbreviations);
+            Assert.NotEqual(UnitAbbreviationsCache.Default, unitParser.Abbreviations);
+            Assert.Equal(UnitsNetSetup.Default.QuantityInfoLookup, unitParser.Quantities);
+        }
+        
         [Theory]
         [InlineData("m^^2", AreaUnit.SquareMeter)]
         [InlineData("cm^^2", AreaUnit.SquareCentimeter)]
         public void Parse_ReturnsUnitMappedByCustomAbbreviation(string customAbbreviation, AreaUnit expected)
         {
-            var abbrevCache = new UnitAbbreviationsCache();
+            var abbrevCache = new UnitAbbreviationsCache([Area.Info]);
             abbrevCache.MapUnitToAbbreviation(expected, customAbbreviation);
             var parser = new UnitParser(abbrevCache);
 
@@ -59,6 +87,8 @@ public void Parse_GivenAbbreviationsThatAreAmbiguousWhenLowerCase_ReturnsCorrect
         [Fact]
         public void Parse_NullAbbreviation_Throws_ArgumentNullException()
         {
+            Assert.Throws<ArgumentNullException>(() => UnitsNetSetup.Default.UnitParser.Parse<LengthUnit>(null!));
+            Assert.Throws<ArgumentNullException>(() => UnitsNetSetup.Default.UnitParser.Parse(null!, Length.Info.UnitInfos));
             Assert.Throws<ArgumentNullException>(() => UnitsNetSetup.Default.UnitParser.Parse(null!, typeof(LengthUnit)));
         }
 
@@ -129,9 +159,12 @@ public void Parse_AmbiguousUnitsThrowsException()
         [InlineData("kg", "ru-RU", MassUnit.Kilogram)] // should work with the "FallbackCulture"
         public void ParseMassUnit_GivenCulture(string str, string cultureName, Enum expectedUnit)
         {
-            Assert.Equal(expectedUnit, UnitsNetSetup.Default.UnitParser.Parse<MassUnit>(str, CultureInfo.GetCultureInfo(cultureName)));
+            var formatProvider = CultureInfo.GetCultureInfo(cultureName);
+            UnitParser unitParser = UnitsNetSetup.Default.UnitParser;
+            
+            Assert.Equal(expectedUnit, unitParser.Parse<MassUnit>(str, formatProvider));
         }
-
+        
         [Fact]
         public void Parse_MappedCustomUnit()
         {
@@ -150,7 +183,7 @@ public void Parse_LengthUnit_MM_ThrowsExceptionDescribingTheAmbiguity()
             var ex = Assert.Throws<AmbiguousUnitParseException>(() => UnitsNetSetup.Default.UnitParser.Parse<LengthUnit>("MM"));
             Assert.Equal("""Cannot parse "MM" since it matches multiple units: Megameter ("Mm"), Millimeter ("mm").""", ex.Message);
         }
-
+        
         [Fact]
         public void TryParse_WithNullAbbreviation_ReturnsFalse()
         {
@@ -163,13 +196,20 @@ public void TryParse_WithNullAbbreviation_ReturnsFalse()
             {
                 var success = unitParser.TryParse(null, typeof(LengthUnit), out Enum? _);
                 Assert.False(success);
+            }, () =>
+            {
+                var success = unitParser.TryParse(null, [], null, out UnitInfo<LengthUnit>? _);
+                Assert.False(success);
             });
         }
 
-        [Fact]
-        public void TryParse_UnknownAbbreviation_ReturnsFalse()
+        [Theory]
+        [InlineData("")] 
+        [InlineData("z^2")]
+        [InlineData("nonexistingunit")]
+        public void TryParse_UnknownAbbreviation_ReturnsFalse(string unknownAreaAbbreviation)
         {
-            Assert.False(UnitsNetSetup.Default.UnitParser.TryParse("nonexistingunit", out AreaUnit _));
+            Assert.False(UnitsNetSetup.Default.UnitParser.TryParse(unknownAreaAbbreviation, out AreaUnit _));
         }
 
         [Fact]
@@ -177,6 +217,7 @@ public void TryParse_WithAmbiguousUnits_ReturnsFalse()
         {
             UnitParser unitParser = UnitsNetSetup.Default.UnitParser;
             Assert.False(unitParser.TryParse("pt", CultureInfo.InvariantCulture, out LengthUnit _));
+            Assert.False(unitParser.TryParse("pt", Length.Info.UnitInfos, CultureInfo.InvariantCulture, out UnitInfo<LengthUnit>? _));
         }
 
         [Theory]
@@ -197,5 +238,60 @@ public void TryParseMassUnit_GivenCulture(string str, string cultureName, Enum e
             Assert.True(success);
             Assert.Equal(expectedUnit, unitParsed);
         }
+
+        [Fact]
+        public void TryGetUnitFromAbbreviation_WithLocalizedUnit_MatchingCulture_ReturnsTrue()
+        {
+            var formatProvider = CultureInfo.GetCultureInfo("ru-RU");
+            UnitParser unitParser = UnitsNetSetup.Default.UnitParser;
+
+            var success = unitParser.TryGetUnitFromAbbreviation("кг", formatProvider, out UnitInfo? unitInfo);
+
+            Assert.True(success);
+            Assert.NotNull(unitInfo);
+            Assert.Equal(MassUnit.Kilogram, unitInfo.Value);
+        }
+
+        [Fact]
+        public void TryGetUnitFromAbbreviation_MatchingFallbackCulture_ReturnsTrue()
+        {
+            var formatProvider = CultureInfo.GetCultureInfo("ru-RU");
+            UnitParser unitParser = UnitsNetSetup.Default.UnitParser;
+
+            var success = unitParser.TryGetUnitFromAbbreviation("kg", formatProvider, out UnitInfo? unitInfo);
+            
+            Assert.True(success);
+            Assert.NotNull(unitInfo);
+            Assert.Equal(MassUnit.Kilogram, unitInfo.Value);
+        }
+
+        [Fact]
+        public void TryGetUnitFromAbbreviation_WithNullString_ReturnsFalse()
+        {
+            var success = UnitsNetSetup.Default.UnitParser.TryGetUnitFromAbbreviation(null, CultureInfo.InvariantCulture, out UnitInfo? _);
+            
+            Assert.False(success);
+        }
+
+        [Fact]
+        public void GetUnitFromAbbreviation_GivenAbbreviationsThatAreAmbiguousWhenLowerCase_ReturnsCorrectUnit()
+        {
+            Assert.Equal(PressureUnit.Megabar, UnitParser.Default.GetUnitFromAbbreviation("Mbar", CultureInfo.InvariantCulture).Value);
+            Assert.Equal(PressureUnit.Millibar, UnitParser.Default.GetUnitFromAbbreviation("mbar", CultureInfo.InvariantCulture).Value);
+        }
+
+        [Fact]
+        public void GetUnitFromAbbreviation_NullAbbreviation_Throws_ArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => UnitsNetSetup.Default.UnitParser.GetUnitFromAbbreviation(null!, CultureInfo.InvariantCulture));
+        }
+        
+        [Theory]
+        [InlineData("z^2")]
+        [InlineData("nonexistingunit")]
+        public void GetUnitFromAbbreviation_UnknownAbbreviationThrowsUnitNotFoundException(string unknownAbbreviation)
+        {
+            Assert.Throws<UnitNotFoundException>(() => UnitsNetSetup.Default.UnitParser.GetUnitFromAbbreviation(unknownAbbreviation, CultureInfo.InvariantCulture));
+        }
     }
 }
diff --git a/UnitsNet/CustomCode/UnitAbbreviationsCache.cs b/UnitsNet/CustomCode/UnitAbbreviationsCache.cs
index 812c3eccce..9f083fd6ef 100644
--- a/UnitsNet/CustomCode/UnitAbbreviationsCache.cs
+++ b/UnitsNet/CustomCode/UnitAbbreviationsCache.cs
@@ -284,9 +284,10 @@ public string GetDefaultAbbreviation(UnitKey unitKey, IFormatProvider? formatPro
         ///     Thrown when no unit information is found for the specified
         ///     <paramref name="unit" />.
         /// </exception>
-        public string[] GetUnitAbbreviations<TUnitType>(TUnitType unit, IFormatProvider? formatProvider = null) where TUnitType : struct, Enum
+        public IReadOnlyList<string> GetUnitAbbreviations<TUnitType>(TUnitType unit, IFormatProvider? formatProvider = null)
+            where TUnitType : struct, Enum
         {
-            return GetUnitAbbreviations(UnitKey.ForUnit(unit), formatProvider).ToArray(); // TODO can we change this to return an IReadOnlyList (as the GetAbbreviations)?
+            return GetUnitAbbreviations(UnitKey.ForUnit(unit), formatProvider);
         }
 
         /// <summary>
@@ -300,9 +301,9 @@ public string[] GetUnitAbbreviations<TUnitType>(TUnitType unit, IFormatProvider?
         ///     Thrown when no unit information is found for the specified
         ///     <paramref name="unitType" /> and <paramref name="unitValue" />.
         /// </exception>
-        public string[] GetUnitAbbreviations(Type unitType, int unitValue, IFormatProvider? formatProvider = null)
+        public IReadOnlyList<string> GetUnitAbbreviations(Type unitType, int unitValue, IFormatProvider? formatProvider = null)
         {
-            return GetUnitAbbreviations(new UnitKey(unitType, unitValue), formatProvider).ToArray(); // TODO can we change this to return an IReadOnlyList (as the GetAbbreviations)?
+            return GetUnitAbbreviations(new UnitKey(unitType, unitValue), formatProvider);
         }
         
         /// <summary>
@@ -367,30 +368,6 @@ public IReadOnlyList<string> GetAllUnitAbbreviationsForQuantity(Type unitEnumTyp
             return allAbbreviations;
         }
 
-        /// <summary>
-        ///    Get all abbreviations for the given unit and culture.
-        /// </summary>
-        /// <param name="unitInfo">The unit.</param>
-        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
-        /// <returns>The list of abbreviations mapped for this unit. The first in the list is the primary abbreviation used by ToString().</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="unitInfo"/> was null.</exception>
-        /// <exception cref="UnitNotFoundException">
-        ///     Thrown when the specified <paramref name="unitInfo" /> is not registered with the associated <see cref="Quantities"/>.
-        /// </exception>
-        public IReadOnlyList<string> GetAbbreviations(UnitInfo unitInfo, IFormatProvider? formatProvider = null) // TODO see about removing this overload
-        {
-            if (unitInfo == null) throw new ArgumentNullException(nameof(unitInfo));
-
-            unitInfo = Quantities.GetUnitInfo(unitInfo.UnitKey); // makes sure that the unit is part of the mapped quantities
-
-            if (formatProvider is not CultureInfo culture)
-            {
-                culture = CultureInfo.CurrentCulture;
-            }
-
-            return GetAbbreviationsWithFallbackCulture(unitInfo, culture);
-        }
-
         /// <summary>
         ///    Get all abbreviations for the given unit and culture.
         /// </summary>
diff --git a/UnitsNet/CustomCode/UnitParser.cs b/UnitsNet/CustomCode/UnitParser.cs
index 76311f853c..4b1e49da2d 100644
--- a/UnitsNet/CustomCode/UnitParser.cs
+++ b/UnitsNet/CustomCode/UnitParser.cs
@@ -433,35 +433,6 @@ internal bool TryParse<TUnitInfo>([NotNullWhen(true)] string? unitAbbreviation,
         return unitAbbreviationsPairs;
     }
 
-
-    private List<(UnitInfo UnitInfo, string Abbreviation)> FindAllMatchingUnitsForCulture(string unitAbbreviation, CultureInfo culture,
-        StringComparison comparison)
-    {
-        var unitAbbreviationsPairs = new List<(UnitInfo, string)>();
-        foreach (QuantityInfo quantityInfo in Quantities.Infos)
-        {
-            IReadOnlyList<UnitInfo> unitInfos = quantityInfo.UnitInfos;
-            var nbUnits = unitInfos.Count;
-            for (var i = 0; i < nbUnits; i++)
-            {
-                UnitInfo unitInfo = unitInfos[i];
-                IReadOnlyList<string> abbreviations = Abbreviations.GetAbbreviationsForCulture(unitInfo, culture);
-                var nbAbbreviations = abbreviations.Count;
-                for (var p = 0; p < nbAbbreviations; p++)
-                {
-                    var abbreviation = abbreviations[p];
-                    if (unitAbbreviation.Equals(abbreviation, comparison))
-                    {
-                        unitAbbreviationsPairs.Add((unitInfo, abbreviation));
-                    }
-                }
-            }
-        }
-
-        return unitAbbreviationsPairs;
-    }
-
-
     /// <summary>
     ///     Retrieves the unit information corresponding to the specified unit abbreviation.
     /// </summary>
@@ -491,46 +462,16 @@ public UnitInfo GetUnitFromAbbreviation(string unitAbbreviation, IFormatProvider
     {
         if (unitAbbreviation == null) throw new ArgumentNullException(nameof(unitAbbreviation));
         
-        if (formatProvider is not CultureInfo culture)
-        {
-            culture = CultureInfo.CurrentCulture;
-        }
-        
-        unitAbbreviation = unitAbbreviation.Trim();
-        StringComparison comparison = StringComparison.Ordinal;
-        while (true)
+        List<(UnitInfo UnitInfo, string Abbreviation)> matches = FindAllMatchingUnits(unitAbbreviation, formatProvider);
+        switch (matches.Count)
         {
-            List<(UnitInfo UnitInfo, string Abbreviation)> matches = FindAllMatchingUnitsForCulture(unitAbbreviation, culture, comparison);
-            switch (matches.Count)
-            {
-                case 1:
-                    return matches[0].UnitInfo;
-                case 0:
-                    // Retry with fallback culture, if different.
-                    if (UnitAbbreviationsCache.HasFallbackCulture(culture))
-                    {
-                        culture = UnitAbbreviationsCache.FallbackCulture;
-                        continue;
-                    }
-                    
-                    var normalizedUnitString = NormalizeUnitString(unitAbbreviation);
-                    if (normalizedUnitString != unitAbbreviation)
-                    {
-                        unitAbbreviation = normalizedUnitString;
-                        continue;
-                    }
-
-                    if (comparison == StringComparison.Ordinal)
-                    {
-                        comparison = StringComparison.OrdinalIgnoreCase;
-                        continue;
-                    }
-
-                    throw new UnitNotFoundException($"Unit not found with abbreviation [{unitAbbreviation}].");
-                default:
-                    var unitsCsv = string.Join(", ", matches.Select(x => $"{x.UnitInfo.Name} (\"{x.Abbreviation}\")").OrderBy(x => x));
-                    throw new AmbiguousUnitParseException($"Cannot parse \"{unitAbbreviation}\" since it matches multiple units: {unitsCsv}.");
-            }
+            case 1:
+                return matches[0].UnitInfo;
+            case 0:
+                throw new UnitNotFoundException($"Unit not found with abbreviation [{unitAbbreviation}].");
+            default:
+                var unitsCsv = string.Join(", ", matches.Select(x => $"{x.UnitInfo.Name} (\"{x.Abbreviation}\")").OrderBy(x => x));
+                throw new AmbiguousUnitParseException($"Cannot parse \"{unitAbbreviation}\" since it matches multiple units: {unitsCsv}.");
         }
     }
 
@@ -564,51 +505,82 @@ public bool TryGetUnitFromAbbreviation([NotNullWhen(true)]string? unitAbbreviati
             return false;
         }
         
-        unitAbbreviation = unitAbbreviation.Trim();
-        
+        List<(UnitInfo UnitInfo, string Abbreviation)> matches = FindAllMatchingUnits(unitAbbreviation, formatProvider);
+        if (matches.Count == 1)
+        {
+            unit = matches[0].UnitInfo;
+            return true;
+        }
+
+        unit = null;
+        return false;
+    }
+
+    private List<(UnitInfo UnitInfo, string Abbreviation)> FindAllMatchingUnits(string unitAbbreviation, IFormatProvider? formatProvider)
+    {
         if (formatProvider is not CultureInfo culture)
         {
             culture = CultureInfo.CurrentCulture;
         }
         
+        unitAbbreviation = unitAbbreviation.Trim();
         StringComparison comparison = StringComparison.Ordinal;
         while (true)
         {
             List<(UnitInfo UnitInfo, string Abbreviation)> matches = FindAllMatchingUnitsForCulture(unitAbbreviation, culture, comparison);
-            switch (matches.Count)
+            if (matches.Count != 0)
             {
-                case 1:
-                    unit = matches[0].UnitInfo;
-                    return true;
-                case 0:
-                    // Retry with fallback culture, if different.
-                    if (UnitAbbreviationsCache.HasFallbackCulture(culture))
-                    {
-                        culture = UnitAbbreviationsCache.FallbackCulture;
-                        continue;
-                    }
+                return matches;
+            }
+            
+            // Retry with fallback culture, if different.
+            if (UnitAbbreviationsCache.HasFallbackCulture(culture))
+            {
+                culture = UnitAbbreviationsCache.FallbackCulture;
+                continue;
+            }
                     
-                    var normalizedUnitString = NormalizeUnitString(unitAbbreviation);
-                    if (normalizedUnitString != unitAbbreviation)
-                    {
-                        unitAbbreviation = normalizedUnitString;
-                        continue;
-                    }
+            var normalizedUnitString = NormalizeUnitString(unitAbbreviation);
+            if (normalizedUnitString != unitAbbreviation)
+            {
+                unitAbbreviation = normalizedUnitString;
+                continue;
+            }
 
-                    if (comparison == StringComparison.Ordinal)
+            if (comparison == StringComparison.Ordinal)
+            {
+                comparison = StringComparison.OrdinalIgnoreCase;
+                continue;
+            }
+
+            return matches;
+        }
+    }
+
+    private List<(UnitInfo UnitInfo, string Abbreviation)> FindAllMatchingUnitsForCulture(string unitAbbreviation, CultureInfo culture,
+        StringComparison comparison)
+    {
+        var unitAbbreviationsPairs = new List<(UnitInfo, string)>();
+        foreach (QuantityInfo quantityInfo in Quantities.Infos)
+        {
+            IReadOnlyList<UnitInfo> unitInfos = quantityInfo.UnitInfos;
+            var nbUnits = unitInfos.Count;
+            for (var i = 0; i < nbUnits; i++)
+            {
+                UnitInfo unitInfo = unitInfos[i];
+                IReadOnlyList<string> abbreviations = Abbreviations.GetAbbreviationsForCulture(unitInfo, culture);
+                var nbAbbreviations = abbreviations.Count;
+                for (var p = 0; p < nbAbbreviations; p++)
+                {
+                    var abbreviation = abbreviations[p];
+                    if (unitAbbreviation.Equals(abbreviation, comparison))
                     {
-                        comparison = StringComparison.OrdinalIgnoreCase;
-                        continue;
+                        unitAbbreviationsPairs.Add((unitInfo, abbreviation));
                     }
-                    
-                    unit = null;
-                    return false;
-                default:
-                {
-                    unit = null;
-                    return false;
                 }
             }
         }
+
+        return unitAbbreviationsPairs;
     }
 }
diff --git a/UnitsNet/QuantityFormatter.cs b/UnitsNet/QuantityFormatter.cs
index 34148b3866..38f6cdc36b 100644
--- a/UnitsNet/QuantityFormatter.cs
+++ b/UnitsNet/QuantityFormatter.cs
@@ -170,7 +170,7 @@ private static string FormatUntrimmed<TUnitType>(IQuantity<TUnitType> quantity,
                 {
                     var abbreviations = UnitsNetSetup.Default.UnitAbbreviations.GetUnitAbbreviations(quantity.Unit, formatProvider);
 
-                    if (abbreviationIndex >= abbreviations.Length)
+                    if (abbreviationIndex >= abbreviations.Count)
                     {
                         throw new FormatException($"The \"{format}\" format string is invalid because the index is out of range.");
                     }
@@ -188,7 +188,7 @@ private static string FormatUntrimmed<TUnitType>(IQuantity<TUnitType> quantity,
                 {
                     var abbreviations = UnitsNetSetup.Default.UnitAbbreviations.GetUnitAbbreviations(quantity.Unit, formatProvider);
 
-                    if (abbreviationIndex >= abbreviations.Length)
+                    if (abbreviationIndex >= abbreviations.Count)
                     {
                         throw new FormatException($"The \"{format}\" format string is invalid because the index is out of range.");
                     }

From c503be89d6206a85f51ee0983c89c7929e5e47f2 Mon Sep 17 00:00:00 2001
From: lipchev <lipchev@gmail.com>
Date: Sat, 19 Apr 2025 02:58:23 +0300
Subject: [PATCH 3/3] removed the obsolete benchmark methods

---
 ...reviationsCacheInitializationBenchmarks.cs | 21 -------------------
 1 file changed, 21 deletions(-)

diff --git a/UnitsNet.Benchmark/Initializations/UnitAbbreviationsCacheInitializationBenchmarks.cs b/UnitsNet.Benchmark/Initializations/UnitAbbreviationsCacheInitializationBenchmarks.cs
index 8dd93340eb..4ca3b7a855 100644
--- a/UnitsNet.Benchmark/Initializations/UnitAbbreviationsCacheInitializationBenchmarks.cs
+++ b/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 Mass.GetAbbreviation(Mass.BaseUnit);
-    }
-
-    [Benchmark]
-    public string EmptyWithoutLookup()
-    {
-        var cache = new UnitAbbreviationsCache();
-        return Mass.GetAbbreviation(Mass.BaseUnit);
-    }
-
-    [Benchmark]
-    public string WithSpecificQuantityWithoutLookup()
-    {
-        var cache = new UnitAbbreviationsCache([Mass.Info]);
-        return Mass.GetAbbreviation(Mass.BaseUnit);
-    }
 }