UnitKey: making the constructor internal and renaming the properties

angularsen · lipchev · Apr 13, 2025 · Apr 13, 2025 · Apr 17, 2025 · Apr 18, 2025
commit b027df28ba95491a4d5225be097b74ea3e0a88ef
diff --git a/UnitsNet.Benchmark/Enums/GetBoxedEnumValuesBenchmarks.cs b/UnitsNet.Benchmark/Enums/GetBoxedEnumValuesBenchmarks.cs
@@ -24,7 +24,7 @@ public int GetEnumValues()
             foreach (Enum unitValue in Enum.GetValues(unitType).Cast<Enum>())
             {
                 var unitKey = (UnitKey)unitValue;
-                total += unitKey.UnitValue;
+                total += unitKey.UnitEnumValue;
             }
         }
 
@@ -39,7 +39,7 @@ public int GetEnumValuesWithDictionary()
         {
             foreach (UnitInfo unitInfo in _quantityInfos[unitType].UnitInfos)
             {
-                total += unitInfo.UnitKey.UnitValue;
+                total += unitInfo.UnitKey.UnitEnumValue;
             }
         }
 

diff --git a/UnitsNet.Benchmark/Enums/UnitKeyEqualsBenchmarks.cs b/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()

diff --git a/UnitsNet.Benchmark/Enums/UnitKeyHashCodeBenchmarks.cs b/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()

diff --git a/UnitsNet.Benchmark/Enums/UnitKeyToEnumBenchmarks.cs b/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++;
             }

diff --git a/UnitsNet.Serialization.SystemTextJson/InterfaceQuantityConverterBase.cs b/UnitsNet.Serialization.SystemTextJson/InterfaceQuantityConverterBase.cs
@@ -42,7 +42,7 @@ public override void Write(Utf8JsonWriter writer, IQuantity quantity, JsonSerial
                 WriteValueProperty(writer, quantity, options);
             }
 
-            if (quantity.UnitKey.UnitValue != quantity.QuantityInfo.BaseUnitInfo.UnitKey.UnitValue)
+            if (quantity.UnitKey.UnitEnumValue != quantity.QuantityInfo.BaseUnitInfo.UnitKey.UnitEnumValue)
             {
                 // write the Unit property
                 writer.WritePropertyName(unitProperty);

diff --git a/UnitsNet.Tests/QuantityConversionOptionsTest.cs b/UnitsNet.Tests/QuantityConversionOptionsTest.cs
@@ -46,7 +46,7 @@ public void SetConversionUnits_ShouldAddUnitConversionMapping()
         options.SetConversionUnits(LengthUnit.Meter, MassUnit.Kilogram);
 
         Assert.Contains(options.ConversionUnits, mapping =>
-            mapping.FromUnitKey.UnitType == typeof(LengthUnit) && mapping.ToUnitKey.UnitType == typeof(MassUnit));
+            mapping.FromUnitKey.UnitEnumType == typeof(LengthUnit) && mapping.ToUnitKey.UnitEnumType == typeof(MassUnit));
     }
 
     [Fact]

diff --git a/UnitsNet.Tests/QuantityConversionsBuilderExtensionsTests.cs b/UnitsNet.Tests/QuantityConversionsBuilderExtensionsTests.cs
@@ -648,7 +648,7 @@ public void GetConversionFunctions_WithCustomConversionsAndCustomCachingOptions_
                     UnitConversionMapping unitConversionKey = pair.Key;
                     CustomQuantityConversionExpressionMapping expressionMapping = pair.Value;
                     ConversionExpression conversionExpression = expressionMapping.ConversionExpression;
-                    var conversionKey = new QuantityConversionKey(unitConversionKey.FromUnitKey, unitConversionKey.ToUnitKey.UnitType);
+                    var conversionKey = new QuantityConversionKey(unitConversionKey.FromUnitKey, unitConversionKey.ToUnitKey.UnitEnumType);
                     Assert.Contains(conversionKey, conversionExpressions);
                     Assert.Equal(expressionMapping.TargetUnit.UnitKey, conversionExpressions[conversionKey].TargetUnit);
                     Assert.Equal(conversionExpression.Evaluate(10), conversionExpressions[conversionKey].Convert(10));
@@ -657,7 +657,7 @@ public void GetConversionFunctions_WithCustomConversionsAndCustomCachingOptions_
             () =>
             {
                 // all generated conversions from a DensityUnit are a function of the custom conversion expressions in our customConversionFromDensity
-                Assert.All(conversionExpressions.Where(x => x.Key.FromUnit.UnitType == typeof(DensityUnit)),
+                Assert.All(conversionExpressions.Where(x => x.Key.FromUnit.UnitEnumType == typeof(DensityUnit)),
                     pair =>
                     {
                         QuantityConversionKey conversionKey = pair.Key;
@@ -681,7 +681,7 @@ public void GetConversionFunctions_WithCustomConversionsAndCustomCachingOptions_
             () =>
             {
                 // all generated conversions from a SpecificVolumeUnit are a function of the custom conversion expressions in our customConversionFromSpecificVolume
-                Assert.All(conversionExpressions.Where(x => x.Key.FromUnit.UnitType == typeof(SpecificVolumeUnit)),
+                Assert.All(conversionExpressions.Where(x => x.Key.FromUnit.UnitEnumType == typeof(SpecificVolumeUnit)),
                     pair =>
                     {
                         QuantityConversionKey conversionKey = pair.Key;
@@ -772,7 +772,7 @@ public void GetConversionFunctions_WithUnitConversionMappings_ReturnsTheSpecifie
             Assert.Equal(expectedValue, conversionExpressions[conversionKey].Convert(valueToConvert));
             Assert.Equal(toUnit.UnitKey, conversionExpressions[conversionKey].TargetUnit);
             // this maybe a bit redundant but that's the only covering line for the ResultType property (its only used for the default equality contract)
-            Assert.Equal(conversionKey.ResultType, conversionExpressions[conversionKey].TargetUnit.UnitType); 
+            Assert.Equal(conversionKey.ResultType, conversionExpressions[conversionKey].TargetUnit.UnitEnumType); 
             if (reduceConstants)
             {
                 Assert.True(IsReduced(conversionExpressions[conversionKey].Convert(1)));
@@ -846,15 +846,15 @@ public void GetConversionFunctions_WithUnitConversionMappingsAndCustomFunctions_
         {
             Assert.All(conversionMappingOptions.ConversionExpressions, pair =>
             {
-                var conversionKey = new QuantityConversionKey(pair.Key.FromUnitKey, pair.Key.ToUnitKey.UnitType);
+                var conversionKey = new QuantityConversionKey(pair.Key.FromUnitKey, pair.Key.ToUnitKey.UnitEnumType);
                 Assert.True(conversionExpressions.ContainsKey(conversionKey));
                 Assert.Equal(pair.Value.ConversionExpression.Evaluate(10), conversionExpressions[conversionKey].Convert(10));
             });
         }, () =>
         {
             Assert.All(conversionMappingOptions.CustomUnitMappings, pair =>
             {
-                var conversionKey = new QuantityConversionKey(pair.Key.FromUnitKey, pair.Key.ToUnitKey.UnitType);
+                var conversionKey = new QuantityConversionKey(pair.Key.FromUnitKey, pair.Key.ToUnitKey.UnitEnumType);
                 UnitInfo sourceUnit = pair.Value.SourceUnit;
                 UnitInfo targetUnit = pair.Value.TargetUnit;
                 QuantityValue valueToConvert = 10;

diff --git a/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs b/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs
@@ -149,6 +149,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()
@@ -178,6 +184,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()
         {

diff --git a/UnitsNet.Tests/UnitKeyTest.cs b/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);
     }
 }
diff --git a/...de/QuantityConverters/Builder/QuantityConversions/QuantityConversionsBuilderExtensions.cs b/...de/QuantityConverters/Builder/QuantityConversions/QuantityConversionsBuilderExtensions.cs
@@ -265,9 +265,9 @@ private static IEnumerable<ConversionEntry> GetConversionsTo(this QuantityInfo f
     {
         // filter the customUnitConversions for specified conversion direction
         Type sourceUnitType = fromQuantity.UnitType;
-        var unitMappings = customUnitConversions.CustomUnitMappings.Where(x => x.Key.FromUnitKey.UnitType == sourceUnitType)
+        var unitMappings = customUnitConversions.CustomUnitMappings.Where(x => x.Key.FromUnitKey.UnitEnumType == sourceUnitType)
             .ToDictionary(x => x.Key.FromUnitKey, pair => pair.Value);
-        var conversionExpressions = customUnitConversions.ConversionExpressions.Where(x => x.Key.FromUnitKey.UnitType == sourceUnitType)
+        var conversionExpressions = customUnitConversions.ConversionExpressions.Where(x => x.Key.FromUnitKey.UnitEnumType == sourceUnitType)
             .ToDictionary(x => x.Key.FromUnitKey, pair => pair.Value);
         // if there are any custom conversionExpressions we ignore the caching mode and calculate an expression for all units
         if (conversionExpressions.Count != 0)
@@ -332,7 +332,7 @@ private static IEnumerable<ConversionEntry> GetConversionsWithAllUnits(this Quan
         {
             if (toQuantity.TryGetConversionFrom(fromUnit, conversionExpression, reduceConstants, out QuantityConversionFunction conversionFunction))
             {
-                yield return new ConversionEntry(new QuantityConversionKey(fromUnit.UnitKey, conversionFunction.TargetUnit.UnitType), conversionFunction);
+                yield return new ConversionEntry(new QuantityConversionKey(fromUnit.UnitKey, conversionFunction.TargetUnit.UnitEnumType), conversionFunction);
             }
             else
             {