♻️Replace obsolete method usages with UnitsNetSetup.Default

Replace obsolete static methods for UnitAbbreviations, QuantityParser, UnitParser and UnitConverter, with the new `UnitsNetSetup.Default` static instance.

# Conflicts:
#	UnitsNet.Tests/GeneratedCode/TestsBase/DoseAreaProductTestsBase.g.cs
#	UnitsNet.Tests/GeneratedCode/TestsBase/ThermalResistanceTestsBase.g.cs
#	UnitsNet.Tests/GeneratedCode/TestsBase/TorquePerLengthTestsBase.g.cs
#	UnitsNet/BaseUnits.cs
#	UnitsNet/GeneratedCode/Quantities/DoseAreaProduct.g.cs
#	UnitsNet/GeneratedCode/Quantities/ThermalInsulance.g.cs
#	UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs
#	UnitsNet/QuantityFormatter.cs

Author: angularsen

CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs

@@ -403,7 +403,7 @@ public static string GetAbbreviation({_unitEnumName} unit)
         /// <param name=""provider"">Format to use for localization. Defaults to <see cref=""CultureInfo.CurrentCulture"" /> if null.</param>
         public static string GetAbbreviation({_unitEnumName} unit, IFormatProvider? provider)
         {{
-            return UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider);
+            return UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit, provider);
         }}
 
         #endregion
@@ -505,7 +505,7 @@ private void GenerateStaticParseMethods()
         /// <param name=""provider"">Format to use when parsing number and unit. Defaults to <see cref=""CultureInfo.CurrentCulture"" /> if null.</param>
         public static {_quantity.Name} Parse(string str, IFormatProvider? provider)
         {{
-            return QuantityParser.Default.Parse<{_quantity.Name}, {_unitEnumName}>(
+            return UnitsNetSetup.Default.QuantityParser.Parse<{_quantity.Name}, {_unitEnumName}>(
                 str,
                 provider,
                 From);
@@ -536,7 +536,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out {_quantity.Name}
         /// <param name=""provider"">Format to use when parsing number and unit. Defaults to <see cref=""CultureInfo.CurrentCulture"" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out {_quantity.Name} result)
         {{
-            return QuantityParser.Default.TryParse<{_quantity.Name}, {_unitEnumName}>(
+            return UnitsNetSetup.Default.QuantityParser.TryParse<{_quantity.Name}, {_unitEnumName}>(
                 str,
                 provider,
                 From,
@@ -569,7 +569,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 UnitParser.Default.Parse<{_unitEnumName}>(str, provider);
+            return UnitsNetSetup.Default.UnitParser.Parse<{_unitEnumName}>(str, provider);
         }}
 
         /// <inheritdoc cref=""TryParseUnit(string,IFormatProvider,out UnitsNet.Units.{_unitEnumName})""/>
@@ -590,7 +590,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 UnitParser.Default.TryParse<{_unitEnumName}>(str, provider, out unit);
+            return UnitsNetSetup.Default.UnitParser.TryParse<{_unitEnumName}>(str, provider, out unit);
         }}
 
         #endregion

CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs

@@ -107,7 +107,7 @@ public static bool TryParse(IFormatProvider? formatProvider, Type quantityType,
             if (!typeof(IQuantity).IsAssignableFrom(quantityType))
                 return false;
 
-            var parser = QuantityParser.Default;
+            var parser = UnitsNetSetup.Default.QuantityParser;
 
             return quantityType switch
             {");

CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs

@@ -809,7 +809,7 @@ public void HasAtLeastOneAbbreviationSpecified()
             var units = Enum.GetValues(typeof({_unitEnumName})).Cast<{_unitEnumName}>();
             foreach (var unit in units)
             {{
-                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
+                var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
             }}
         }}
 

README.md

@@ -230,9 +230,9 @@ if (Quantity.TryParse(typeof(Length), "3cm", out IQuantity quantity2)
 [UnitParser](UnitsNet/CustomCode/UnitParser.cs) parses unit abbreviation strings to unit enum values.
 
 ```c#
-Enum unit = UnitParser.Default.Parse("cm", typeof(LengthUnit)); // LengthUnit.Centimeter
+Enum unit = UnitsNetSetup.Default.UnitParser.Parse("cm", typeof(LengthUnit)); // LengthUnit.Centimeter
 
-if (UnitParser.Default.TryParse("cm", typeof(LengthUnit), out Enum unit2))
+if (UnitsNetSetup.Default.UnitParser.TryParse("cm", typeof(LengthUnit), out Enum unit2))
 {
     // Use unit2 as LengthUnit.Centimeter
 }
@@ -277,14 +277,16 @@ Read more at [Extending-with-Custom-Units](https://github.com/angularsen/UnitsNe
 #### Map between unit enum values and unit abbreviations
 ```c#
 // Map unit enum values to unit abbreviations
-UnitAbbreviationsCache.Default.MapUnitToDefaultAbbreviation(HowMuchUnit.Some, "sm");
-UnitAbbreviationsCache.Default.GetDefaultAbbreviation(HowMuchUnit.Some); // "sm"
-UnitParser.Default.Parse<HowMuchUnit>("sm");  // HowMuchUnit.Some
+var unitAbbreviations = UnitsNetSetup.Default.UnitAbbreviations;
+unitAbbreviations.MapUnitToDefaultAbbreviation(HowMuchUnit.Some, "sm");
+unitAbbreviations.GetDefaultAbbreviation(HowMuchUnit.Some); // "sm"
+
+UnitsNetSetup.Default.UnitParser.Parse<HowMuchUnit>("sm");  // HowMuchUnit.Some
 ```
 
 #### Convert between units of custom quantity
 ```c#
-var unitConverter = UnitConverter.Default;
+var unitConverter = UnitsNetSetup.Default.UnitConverter;
 unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Lots, HowMuchUnit.Some, x => new HowMuch(x.Value * 2, HowMuchUnit.Some));
 unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Tons, HowMuchUnit.Lots, x => new HowMuch(x.Value * 10, HowMuchUnit.Lots));
 unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Tons, HowMuchUnit.Some, x => new HowMuch(x.Value * 20, HowMuchUnit.Some));
@@ -299,23 +301,32 @@ Console.WriteLine(Convert(HowMuchUnit.Tons)); // 10 tns
 ```
 
 #### Parse custom quantity
-[QuantityParser](UnitsNet/CustomCode/QuantityParser.cs) parses quantity strings to `IQuantity` by providing a `UnitAbbreviationsCache` with custom units and unit abbreviations.
+[QuantityParser](UnitsNet/CustomCode/QuantityParser.cs) parses quantity strings to `IQuantity` by mapping custom units to unit abbreviations in `UnitAbbreviationsCache`.
 
 ```c#
-// Alternatively, manipulate the global UnitAbbreviationsCache.Default.
-var unitAbbreviationsCache = new UnitAbbreviationsCache();
+// Map custom units to abbreviations
+var unitAbbreviationsCache = UnitsNetSetup.Default.UnitAbbreviations;
 unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.Some, "sm");
 unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.ATon, "tn");
 
-var quantityParser = new QuantityParser(unitAbbreviationsCache);
+var quantityParser = UnitsNetSetup.Default.QuantityParser;
 
-// 1 Some
+// "1 sm" => new HowMuch(1, HowMuchUnit.Some)
 HowMuch q = quantityParser.Parse<HowMuch, HowMuchUnit>(
     str: "1 sm",
     formatProvider: null,
     fromDelegate: (value, unit) => new HowMuch((double) value, unit));
 ```
 
+```c#
+// Alternatively, create your own instances to not change the global singleton instances.
+var unitAbbreviationsCache = UnitAbbreviationsCache.CreateDefault(); // or .CreateEmpty()
+unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.Some, "sm");
+unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.ATon, "tn");
+
+var quantityParser = new QuantityParser(unitAbbreviationsCache);
+```
+
 
 ### Example: Unit converter app
 [Source code](https://github.com/angularsen/UnitsNet/tree/master/Samples/UnitConverter.Wpf) for `Samples/UnitConverter.Wpf`<br/>