QuantityFormatter: Take UnitAbbreviationsCache instance, Format with TQuantity

CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs

@@ -290,25 +290,30 @@ private void GenerateProperties()
         /// </summary>
         public double Value => _value;
 
-        /// <inheritdoc />
-        double IQuantity.Value => _value;
-
-        Enum IQuantity.Unit => Unit;
-
         /// <inheritdoc />
         public {_unitEnumName} Unit => _unit.GetValueOrDefault(BaseUnit);
 
         /// <inheritdoc />
         public QuantityInfo<{_unitEnumName}> QuantityInfo => Info;
 
-        /// <inheritdoc cref=""IQuantity.QuantityInfo""/>
-        QuantityInfo IQuantity.QuantityInfo => Info;
-
         /// <summary>
         ///     The <see cref=""BaseDimensions"" /> of this quantity.
         /// </summary>
         public BaseDimensions Dimensions => {_quantity.Name}.BaseDimensions;
 
+        #region Explicit implementations
+
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        Enum IQuantity.Unit => Unit;
+
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        UnitKey IQuantity.UnitKey => UnitKey.ForUnit(Unit);
+
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        QuantityInfo IQuantity.QuantityInfo => Info;
+
+        #endregion
+
         #endregion
 ");
         }
@@ -1167,7 +1172,7 @@ public string ToString(IFormatProvider? provider)
             return ToString(null, provider);
         }}
 
-        /// <inheritdoc cref=""QuantityFormatter.Format{{TUnitType}}(IQuantity{{TUnitType}}, string, IFormatProvider)""/>
+        /// <inheritdoc cref=""QuantityFormatter.Format{{TQuantity}}(TQuantity, string?, IFormatProvider?)""/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using <see cref=""CultureInfo.CurrentCulture"" />.
         /// </summary>
@@ -1178,16 +1183,13 @@ public string ToString(string? format)
             return ToString(format, null);
         }}
 
-        /// <inheritdoc cref=""QuantityFormatter.Format{{TUnitType}}(IQuantity{{TUnitType}}, string, IFormatProvider)""/>
+        /// <inheritdoc cref=""QuantityFormatter.Format{{TQuantity}}(TQuantity, string?, IFormatProvider?)""/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref=""CultureInfo.CurrentCulture"" /> if null.
         /// </summary>
-        /// <param name=""format"">The format string.</param>
-        /// <param name=""provider"">Format to use for localization and number formatting. Defaults to <see cref=""CultureInfo.CurrentCulture"" /> if null.</param>
-        /// <returns>The string representation.</returns>
         public string ToString(string? format, IFormatProvider? provider)
         {{
-            return QuantityFormatter.Format<{_unitEnumName}>(this, format, provider);
+            return QuantityFormatter.Default.Format(this, format, provider);
         }}
 
         #endregion

UnitsNet.Benchmark/Conversions/ToString/ToStringWithDefaultPrecisionBenchmarks.cs

@@ -9,7 +9,7 @@ namespace UnitsNet.Benchmark.Conversions.ToString;
 
 [MemoryDiagnoser]
 [SimpleJob(RuntimeMoniker.Net48)]
-[SimpleJob(RuntimeMoniker.Net80)]
+[SimpleJob(RuntimeMoniker.Net90)]
 public class ToStringWithDefaultPrecisionBenchmarks
 {
     private static readonly double Value = 123.456;

UnitsNet.Benchmark/Enums/UnitKeyEqualsBenchmarks.cs

@@ -16,11 +16,11 @@ public class UnitKeyEqualsBenchmarks
 
     private static readonly UnitKey UnitKey = UnitKey.ForUnit(VolumeUnit.CubicMeter);
     private static readonly UnitKey OtherUnitKey = UnitKey.ForUnit(VolumeUnit.AcreFoot);
-    private readonly Type OtherUnitType = UnitKey.UnitType;
-    private readonly int OtherUnitValue = UnitKey.UnitValue;
+    private readonly Type OtherUnitType = UnitKey.UnitEnumType;
+    private readonly int OtherUnitValue = UnitKey.UnitEnumValue;
 
-    private readonly Type UnitType = UnitKey.UnitType;
-    private readonly int UnitValue = UnitKey.UnitValue;
+    private readonly Type UnitType = UnitKey.UnitEnumType;
+    private readonly int UnitValue = UnitKey.UnitEnumValue;
 
     [Benchmark(Baseline = true)]
     public bool EqualsRecord()

UnitsNet.Benchmark/Enums/UnitKeyHashCodeBenchmarks.cs

@@ -17,8 +17,8 @@ public class UnitKeyHashCodeBenchmarks
 
     private static readonly UnitKey UnitKey = UnitKey.ForUnit(VolumeUnit.CubicMeter);
 
-    private readonly Type UnitType = UnitKey.UnitType;
-    private readonly int UnitValue = UnitKey.UnitValue;
+    private readonly Type UnitType = UnitKey.UnitEnumType;
+    private readonly int UnitValue = UnitKey.UnitEnumValue;
 
     [Benchmark(Baseline = true)]
     public int GetHashCodeRecord()

UnitsNet.Benchmark/Enums/UnitKeyToEnumBenchmarks.cs

@@ -23,7 +23,7 @@ public int ManualCast()
         var total = 0;
         for (var i = 0; i < NbIterations; i++)
         {
-            if ((MassUnit)unitKey.UnitValue == MassUnit.Gram)
+            if ((MassUnit)unitKey.UnitEnumValue == MassUnit.Gram)
             {
                 total++;
             }

UnitsNet.Tests/CustomQuantities/HowMuch.cs

@@ -49,6 +49,11 @@ QuantityInfo IQuantity.QuantityInfo
         {
             get { return Info; }
         }
+
+        public UnitKey UnitKey
+        {
+            get => UnitKey.ForUnit(Unit);
+        }
 
         public double As(Enum unit) => Convert.ToDouble(unit);
 

UnitsNet.Tests/QuantityFormatterTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using UnitsNet.Tests.Helpers;
 using Xunit;
 
 namespace UnitsNet.Tests
@@ -95,9 +96,9 @@ public static void StandardNumericFormatStrings_Equals_ValueWithFormatStringAndA
             var length = Length.FromMeters(123456789.987654321);
 
             var expected = string.Format(CultureInfo.CurrentCulture, $"{{0:{format}}} {{1:a}}", length.Value, length);
-            Assert.Equal(expected, QuantityFormatter.Format(length, format));
+            Assert.Equal(expected, QuantityFormatter.Default.Format(length, format));
         }
-        
+
         [Theory]
         [InlineData("U")]
         [InlineData("u")]
@@ -140,9 +141,9 @@ public static void StandardNumericFormatStrings_Equals_ValueWithFormatStringAndA
         public static void Format_WithUnsupportedFormatString_ThrowsFormatException(string format)
         {
             var length = Length.FromMeters(123456789.987654321);
-            Assert.Throws<FormatException>(() => QuantityFormatter.Format(length, format));
+            Assert.Throws<FormatException>(() => QuantityFormatter.Default.Format(length, format));
         }
-        
+
         [Fact]
         public static void StandardNumericFormatStringsAsPartOfLongerFormatStringsWork()
         {
@@ -173,7 +174,27 @@ public static void CustomNumericFormatStrings_Equals_ValueWithFormatStringAndAbb
             var length = Length.FromMeters(123456789.987654321);
 
             var expected = string.Format(CultureInfo.CurrentCulture, $"{{0:{format}}} {{1:a}}", length.Value, length);
-            Assert.Equal(expected, QuantityFormatter.Format(length, format));
+            Assert.Equal(expected, QuantityFormatter.Default.Format(length, format));
+        }
+
+        [Fact]
+        public void Format_WithoutFormatParameter_FormatsWithGeneralFormatWithCurrentCulture()
+        {
+            using var cultureScope = new CultureScope(CultureInfo.InvariantCulture);
+            var length = Length.FromMeters(123.321);
+            var expected = "123.321 m";
+            var actual = QuantityFormatter.Default.Format(length);
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void Format_WithFormatParameter_FormatsWithCurrentCulture()
+        {
+            using var cultureScope = new CultureScope(CultureInfo.InvariantCulture);
+            var length = Length.FromMeters(123.321);
+            var expected = "123.321 m";
+            var actual = QuantityFormatter.Format(length, "G");
+            Assert.Equal(expected, actual);
         }
     }
 }

UnitsNet.Tests/QuantityTest.cs

@@ -180,7 +180,7 @@ public void TryFrom_GivenValueAndUnit_ReturnsQuantity()
         [Fact]
         public void TryParse_GivenInvalidQuantityType_ReturnsFalseAndNullQuantity()
         {
-            Assert.False(Quantity.TryParse(InvariantCulture, typeof(DummyIQuantity), "3.0 cm", out IQuantity? parsedLength));
+            Assert.False(Quantity.TryParse(InvariantCulture, typeof(DateTime), "3.0 cm", out IQuantity? parsedLength));
             Assert.Null(parsedLength);
         }
 

UnitsNet.Tests/UnitAbbreviationsCacheTests.cs

@@ -126,6 +126,12 @@ public void GetDefaultAbbreviationFallsBackToInvariantCulture()
             // Assert
             Assert.Equal("Invariant abbreviation for Unit1", abbreviation);
         }
+
+        [Fact]
+        public void GetDefaultAbbreviation_WithNullUnitType_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.Default.GetDefaultAbbreviation(null!, 1));
+        }
 
         [Fact]
         public void GetDefaultAbbreviationThrowsUnitNotFoundExceptionIfNoneExist()
@@ -149,6 +155,12 @@ public void GetAllUnitAbbreviationsForQuantity_WithQuantityWithoutAbbreviations_
             Assert.Empty(unitAbbreviationsCache.GetAllUnitAbbreviationsForQuantity(typeof(HowMuchUnit)));
         }
 
+        [Fact]
+        public void GetAllUnitAbbreviationsForQuantity_WithNullUnitType_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.Default.GetAllUnitAbbreviationsForQuantity(null!));
+        }
+
         [Fact]
         public void GetAllUnitAbbreviationsForQuantity_WithInvalidUnitType_ThrowsArgumentException()
         {

UnitsNet.Tests/UnitKeyTest.cs

@@ -23,16 +23,16 @@ public enum TestUnit
     public void Constructor_ShouldCreateUnitKey(int unitValue)
     {
         var unitKey = new UnitKey(typeof(TestUnit), unitValue);
-        Assert.Equal(typeof(TestUnit), unitKey.UnitType);
-        Assert.Equal(unitValue, unitKey.UnitValue);
+        Assert.Equal(typeof(TestUnit), unitKey.UnitEnumType);
+        Assert.Equal(unitValue, unitKey.UnitEnumValue);
     }
 
     [Fact]
     public void Constructor_WithNullType_ShouldNotThrow()
     {
         var unitKey = new UnitKey(null!, 0);
-        Assert.Null(unitKey.UnitType);
-        Assert.Equal(0, unitKey.UnitValue);
+        Assert.Null(unitKey.UnitEnumType);
+        Assert.Equal(0, unitKey.UnitEnumValue);
     }
 
     [Theory]
@@ -42,8 +42,8 @@ public void Constructor_WithNullType_ShouldNotThrow()
     public void ForUnit_ShouldCreateUnitKey(TestUnit unit)
     {
         var unitKey = UnitKey.ForUnit(unit);
-        Assert.Equal(typeof(TestUnit), unitKey.UnitType);
-        Assert.Equal((int)unit, unitKey.UnitValue);
+        Assert.Equal(typeof(TestUnit), unitKey.UnitEnumType);
+        Assert.Equal((int)unit, unitKey.UnitEnumValue);
     }
 
     [Theory]
@@ -53,8 +53,31 @@ public void ForUnit_ShouldCreateUnitKey(TestUnit unit)
     public void Create_ShouldCreateUnitKey(int unitValue)
     {
         var unitKey = UnitKey.Create<TestUnit>(unitValue);
-        Assert.Equal(typeof(TestUnit), unitKey.UnitType);
-        Assert.Equal(unitValue, unitKey.UnitValue);
+        Assert.Equal(typeof(TestUnit), unitKey.UnitEnumType);
+        Assert.Equal(unitValue, unitKey.UnitEnumValue);
+    }
+
+    [Theory]
+    [InlineData(typeof(TestUnit), 1)]
+    [InlineData(typeof(TestUnit), 2)]
+    [InlineData(typeof(TestUnit), 3)]
+    public void Create_WithUnitTypeAndUnitValue_ShouldCreateUnitKey(Type unitType, int unitValue)
+    {
+        var unitKey = UnitKey.Create(unitType, unitValue);
+        Assert.Equal(unitType, unitKey.UnitEnumType);
+        Assert.Equal(unitValue, unitKey.UnitEnumValue);
+    }
+
+    [Fact]
+    public void Create_WithNullUnitType_ShouldThrowArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => UnitKey.Create(null!, 0));
+    }
+
+    [Fact]
+    public void Create_WithNonEnumType_ShouldThrowArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => UnitKey.Create(typeof(int), 1));
     }
 
     [Theory]
@@ -64,8 +87,8 @@ public void Create_ShouldCreateUnitKey(int unitValue)
     public void ImplicitConversion_ShouldCreateUnitKey(TestUnit unit)
     {
         UnitKey unitKey = unit;
-        Assert.Equal(typeof(TestUnit), unitKey.UnitType);
-        Assert.Equal((int)unit, unitKey.UnitValue);
+        Assert.Equal(typeof(TestUnit), unitKey.UnitEnumType);
+        Assert.Equal((int)unit, unitKey.UnitEnumValue);
     }
 
     [Theory]
@@ -94,8 +117,8 @@ public void ToUnit_ShouldReturnEnum(TestUnit unit)
     public void Default_InitializesWithoutAType()
     {
         var defaultUnitKey = default(UnitKey);
-        Assert.Null(defaultUnitKey.UnitType);
-        Assert.Equal(0, defaultUnitKey.UnitValue);
+        Assert.Null(defaultUnitKey.UnitEnumType);
+        Assert.Equal(0, defaultUnitKey.UnitEnumValue);
     }
 
     [Fact]
@@ -139,7 +162,7 @@ public void Deconstruct_ShouldReturnTheUnitTypeAndUnitValue()
     [InlineData(TestUnit.Unit1, "TestUnit.Unit1")]
     [InlineData(TestUnit.Unit2, "TestUnit.Unit2")]
     [InlineData(TestUnit.Unit3, "TestUnit.Unit3")]
-    [InlineData((TestUnit)(-1), "UnitType: UnitsNet.Tests.UnitKeyTest+TestUnit, UnitValue = -1")]
+    [InlineData((TestUnit)(-1), "UnitEnumType: UnitsNet.Tests.UnitKeyTest+TestUnit, UnitEnumValue = -1")]
     public void GetDebuggerDisplay_ShouldReturnCorrectString(TestUnit unit, string expectedDisplay)
     {
         var unitKey = UnitKey.ForUnit(unit);
@@ -154,6 +177,6 @@ public void GetDebuggerDisplayWithDefault_ShouldReturnCorrectString()
         var defaultUnitKey = default(UnitKey);
         var display = defaultUnitKey.GetType().GetMethod("GetDebuggerDisplay", BindingFlags.NonPublic | BindingFlags.Instance)!
             .Invoke(defaultUnitKey, null);
-        Assert.Equal("UnitType: , UnitValue = 0", display);
+        Assert.Equal("UnitEnumType: , UnitEnumValue = 0", display);
     }
 }