UnitKey: renamed the UnitType and UnitValue to UnitEnumType and UnitEnumValue

lipchev · lipchev · commit 3d7a7c5cecae · 2025-04-19T16:53:57.000+03:00
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.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/UnitsNet/CustomCode/UnitAbbreviationsCache.cs b/UnitsNet/CustomCode/UnitAbbreviationsCache.cs
@@ -267,7 +267,7 @@ public string GetDefaultAbbreviation(UnitKey unitKey, IFormatProvider? formatPro
             IReadOnlyList<string> abbreviations = GetUnitAbbreviations(unitKey, formatProvider);
             if (abbreviations.Count == 0)
             {
-                throw new InvalidOperationException($"No abbreviations were found for {unitKey.UnitType.Name}.{(Enum)unitKey}. Make sure that the unit abbreviations are mapped.");
+                throw new InvalidOperationException($"No abbreviations were found for {unitKey.UnitEnumType.Name}.{(Enum)unitKey}. Make sure that the unit abbreviations are mapped.");
             }
 
             return abbreviations[0];
@@ -463,7 +463,7 @@ private static List<string> ReadAbbreviationsFromResourceFile(UnitInfo unitInfo,
         {
             var abbreviationsList = new List<string>();
             // we currently don't have any way of providing external resource dictionaries
-            Assembly unitAssembly = unitInfo.UnitKey.UnitType.Assembly;
+            Assembly unitAssembly = unitInfo.UnitKey.UnitEnumType.Assembly;
             if (unitAssembly != typeof(UnitAbbreviationsCache).Assembly)
             {
                 return abbreviationsList;
diff --git a/UnitsNet/CustomCode/UnitKey.cs b/UnitsNet/CustomCode/UnitKey.cs
@@ -17,8 +17,8 @@ namespace UnitsNet;
 public readonly record struct UnitKey
 {
     // apparently, on netstandard, the use of auto-properties is significantly slower
-    private readonly Type _unitType;
-    private readonly int _unitValue;
+    private readonly Type _unitEnumType;
+    private readonly int _unitEnumValue;
 
     /// <summary>
     ///     Represents a unique key for a unit type and its corresponding value.
@@ -27,10 +27,10 @@ public readonly record struct UnitKey
     ///     This key is particularly useful when using an enum-based unit in a hash-based collection,
     ///     as it avoids the boxing that would normally occur when casting the enum to <see cref="Enum" />.
     /// </remarks>
-    public UnitKey(Type UnitType, int UnitValue)
+    internal UnitKey(Type UnitEnumType, int UnitEnumValue)
     {
-        _unitType = UnitType;
-        _unitValue = UnitValue;
+        _unitEnumType = UnitEnumType;
+        _unitEnumValue = UnitEnumValue;
     }
 
     /// <summary>
@@ -40,9 +40,9 @@ public UnitKey(Type UnitType, int UnitValue)
     ///     This property holds the <see cref="Type" /> of the unit enumeration associated with this key.
     ///     It is particularly useful for identifying the unit type in scenarios where multiple unit types are used.
     /// </remarks>
-    public Type UnitType
+    public Type UnitEnumType
     {
-        get => _unitType;
+        get => _unitEnumType;
     }
 
     /// <summary>
@@ -52,9 +52,9 @@ public Type UnitType
     ///     This property represents the unique value of the unit within its type, typically corresponding to the underlying
     ///     integer value of an enumeration.
     /// </remarks>
-    public int UnitValue
+    public int UnitEnumValue
     {
-        get => _unitValue;
+        get => _unitEnumValue;
     }
 
     /// <summary>
@@ -81,6 +81,36 @@ public static UnitKey Create<TUnit>(int unitValue)
         return new UnitKey(typeof(TUnit), unitValue);
     }
 
+    /// <summary>
+    ///     Creates a new instance of the <see cref="UnitKey" /> struct for the specified unit type and value.
+    /// </summary>
+    /// <param name="unitType">The type of the unit, which must be an enumeration.</param>
+    /// <param name="unitValue">The integer value representing the unit.</param>
+    /// <returns>A new instance of the <see cref="UnitKey" /> struct.</returns>
+    /// <exception cref="ArgumentNullException">
+    ///     Thrown if <paramref name="unitType" /> is <c>null</c>.
+    /// </exception>
+    /// <exception cref="ArgumentException">
+    ///     Thrown if <paramref name="unitType" /> is not an enumeration type.
+    /// </exception>
+    /// <remarks>
+    ///     This method is useful for creating a <see cref="UnitKey" /> when the unit type and value are known.
+    /// </remarks>
+    public static UnitKey Create(Type unitType, int unitValue)
+    {
+        if (unitType is null)
+        {
+            throw new ArgumentNullException(nameof(unitType));
+        }
+
+        if (!unitType.IsEnum)
+        {
+            throw new ArgumentException($"Unit type must be an enumeration, but was {unitType.FullName}.");
+        }
+
+        return new UnitKey(unitType, unitValue);
+    }
+
     /// <summary>
     ///     Implicitly converts an enumeration value to a <see cref="UnitKey" />.
     /// </summary>
@@ -111,7 +141,7 @@ public static implicit operator UnitKey(Enum unit)
     /// </remarks>
     public static explicit operator Enum(UnitKey unitKey)
     {
-        return (Enum)Enum.ToObject(unitKey._unitType, unitKey._unitValue);
+        return (Enum)Enum.ToObject(unitKey._unitEnumType, unitKey._unitEnumValue);
     }
 
     /// <summary>
@@ -129,25 +159,25 @@ public static explicit operator Enum(UnitKey unitKey)
     /// </remarks>
     public TUnit ToUnit<TUnit>() where TUnit : struct, Enum
     {
-        if (typeof(TUnit) != _unitType)
+        if (typeof(TUnit) != _unitEnumType)
         {
-            throw new InvalidOperationException($"Cannot convert UnitKey of type {_unitType} to {typeof(TUnit)}.");
+            throw new InvalidOperationException($"Cannot convert UnitKey of type {_unitEnumType} to {typeof(TUnit)}.");
         }
 
-        var unitValue = _unitValue;
+        var unitValue = _unitEnumValue;
         return Unsafe.As<int, TUnit>(ref unitValue);
     }
 
     private string GetDebuggerDisplay()
     {
         try
         {
-            var unitName = Enum.GetName(_unitType, _unitValue);
-            return string.IsNullOrEmpty(unitName) ? $"{nameof(UnitType)}: {_unitType}, {nameof(UnitValue)} = {_unitValue}" : $"{_unitType.Name}.{unitName}";
+            var unitName = Enum.GetName(_unitEnumType, _unitEnumValue);
+            return string.IsNullOrEmpty(unitName) ? $"{nameof(UnitEnumType)}: {_unitEnumType}, {nameof(UnitEnumValue)} = {_unitEnumValue}" : $"{_unitEnumType.Name}.{unitName}";
         }
         catch
         {
-            return $"{nameof(UnitType)}: {_unitType}, {nameof(UnitValue)} = {_unitValue}";
+            return $"{nameof(UnitEnumType)}: {_unitEnumType}, {nameof(UnitEnumValue)} = {_unitEnumValue}";
         }
     }
 
@@ -162,8 +192,8 @@ private string GetDebuggerDisplay()
     /// </remarks>
     public void Deconstruct(out Type unitType, out int unitValue)
     {
-        unitType = _unitType;
-        unitValue = _unitValue;
+        unitType = _unitEnumType;
+        unitValue = _unitEnumValue;
     }
 
     #region Equality members
@@ -172,21 +202,21 @@ public void Deconstruct(out Type unitType, out int unitValue)
     public bool Equals(UnitKey other)
     {
         // implementing the Equality members on net48 is 5x faster than the default
-        return _unitType == other._unitType && _unitValue == other._unitValue;
+        return _unitEnumType == other._unitEnumType && _unitEnumValue == other._unitEnumValue;
     }
 
     /// <inheritdoc />
     public override int GetHashCode()
     {
         // implementing the Equality members on net48 is 5x faster than the default
-        if (_unitType == null)
+        if (_unitEnumType == null)
         {
-            return _unitValue;
+            return _unitEnumValue;
         }
 
         unchecked
         {
-            return (_unitType.GetHashCode() * 397) ^ _unitValue;
+            return (_unitEnumType.GetHashCode() * 397) ^ _unitEnumValue;
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ public int ManualCast()`
`23`	`23`	`var total = 0;`
`24`	`24`	`for (var i = 0; i < NbIterations; i++)`
`25`	`25`	`{`
`26`		`- if ((MassUnit)unitKey.UnitValue == MassUnit.Gram)`
	`26`	`+ if ((MassUnit)unitKey.UnitEnumValue == MassUnit.Gram)`
`27`	`27`	`{`
`28`	`28`	`total++;`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -267,7 +267,7 @@ public string GetDefaultAbbreviation(UnitKey unitKey, IFormatProvider? formatPro`
`267`	`267`	`IReadOnlyList<string> abbreviations = GetUnitAbbreviations(unitKey, formatProvider);`
`268`	`268`	`if (abbreviations.Count == 0)`
`269`	`269`	`{`
`270`		`- throw new InvalidOperationException($"No abbreviations were found for {unitKey.UnitType.Name}.{(Enum)unitKey}. Make sure that the unit abbreviations are mapped.");`
	`270`	`+ throw new InvalidOperationException($"No abbreviations were found for {unitKey.UnitEnumType.Name}.{(Enum)unitKey}. Make sure that the unit abbreviations are mapped.");`
`271`	`271`	`}`
`272`	`272`
`273`	`273`	`return abbreviations[0];`
`@@ -463,7 +463,7 @@ private static List<string> ReadAbbreviationsFromResourceFile(UnitInfo unitInfo,`
`463`	`463`	`{`
`464`	`464`	`var abbreviationsList = new List<string>();`
`465`	`465`	`// we currently don't have any way of providing external resource dictionaries`
`466`		`- Assembly unitAssembly = unitInfo.UnitKey.UnitType.Assembly;`
	`466`	`+ Assembly unitAssembly = unitInfo.UnitKey.UnitEnumType.Assembly;`
`467`	`467`	`if (unitAssembly != typeof(UnitAbbreviationsCache).Assembly)`
`468`	`468`	`{`
`469`	`469`	`return abbreviationsList;`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,8 @@ namespace UnitsNet;`
`17`	`17`	`public readonly record struct UnitKey`
`18`	`18`	`{`
`19`	`19`	`// apparently, on netstandard, the use of auto-properties is significantly slower`
`20`		`- private readonly Type _unitType;`
`21`		`- private readonly int _unitValue;`
	`20`	`+ private readonly Type _unitEnumType;`
	`21`	`+ private readonly int _unitEnumValue;`
`22`	`22`
`23`	`23`	`/// <summary>`
`24`	`24`	`/// Represents a unique key for a unit type and its corresponding value.`
`@@ -27,10 +27,10 @@ public readonly record struct UnitKey`
`27`	`27`	`/// This key is particularly useful when using an enum-based unit in a hash-based collection,`
`28`	`28`	`/// as it avoids the boxing that would normally occur when casting the enum to <see cref="Enum" />.`
`29`	`29`	`/// </remarks>`
`30`		`- public UnitKey(Type UnitType, int UnitValue)`
	`30`	`+ internal UnitKey(Type UnitEnumType, int UnitEnumValue)`
`31`	`31`	`{`
`32`		`- _unitType = UnitType;`
`33`		`- _unitValue = UnitValue;`
	`32`	`+ _unitEnumType = UnitEnumType;`
	`33`	`+ _unitEnumValue = UnitEnumValue;`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`/// <summary>`
`@@ -40,9 +40,9 @@ public UnitKey(Type UnitType, int UnitValue)`
`40`	`40`	`/// This property holds the <see cref="Type" /> of the unit enumeration associated with this key.`
`41`	`41`	`/// It is particularly useful for identifying the unit type in scenarios where multiple unit types are used.`
`42`	`42`	`/// </remarks>`
`43`		`- public Type UnitType`
	`43`	`+ public Type UnitEnumType`
`44`	`44`	`{`
`45`		`- get => _unitType;`
	`45`	`+ get => _unitEnumType;`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`/// <summary>`
`@@ -52,9 +52,9 @@ public Type UnitType`
`52`	`52`	`/// This property represents the unique value of the unit within its type, typically corresponding to the underlying`
`53`	`53`	`/// integer value of an enumeration.`
`54`	`54`	`/// </remarks>`
`55`		`- public int UnitValue`
	`55`	`+ public int UnitEnumValue`
`56`	`56`	`{`
`57`		`- get => _unitValue;`
	`57`	`+ get => _unitEnumValue;`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`/// <summary>`
`@@ -81,6 +81,36 @@ public static UnitKey Create<TUnit>(int unitValue)`
`81`	`81`	`return new UnitKey(typeof(TUnit), unitValue);`
`82`	`82`	`}`
`83`	`83`
	`84`	`+ /// <summary>`
	`85`	`+ /// Creates a new instance of the <see cref="UnitKey" /> struct for the specified unit type and value.`
	`86`	`+ /// </summary>`
	`87`	`+ /// <param name="unitType">The type of the unit, which must be an enumeration.</param>`
	`88`	`+ /// <param name="unitValue">The integer value representing the unit.</param>`
	`89`	`+ /// <returns>A new instance of the <see cref="UnitKey" /> struct.</returns>`
	`90`	`+ /// <exception cref="ArgumentNullException">`
	`91`	`+ /// Thrown if <paramref name="unitType" /> is <c>null</c>.`
	`92`	`+ /// </exception>`
	`93`	`+ /// <exception cref="ArgumentException">`
	`94`	`+ /// Thrown if <paramref name="unitType" /> is not an enumeration type.`
	`95`	`+ /// </exception>`
	`96`	`+ /// <remarks>`
	`97`	`+ /// This method is useful for creating a <see cref="UnitKey" /> when the unit type and value are known.`
	`98`	`+ /// </remarks>`
	`99`	`+ public static UnitKey Create(Type unitType, int unitValue)`
	`100`	`+ {`
	`101`	`+ if (unitType is null)`
	`102`	`+ {`
	`103`	`+ throw new ArgumentNullException(nameof(unitType));`
	`104`	`+ }`
	`105`	`+`
	`106`	`+ if (!unitType.IsEnum)`
	`107`	`+ {`
	`108`	`+ throw new ArgumentException($"Unit type must be an enumeration, but was {unitType.FullName}.");`
	`109`	`+ }`
	`110`	`+`
	`111`	`+ return new UnitKey(unitType, unitValue);`
	`112`	`+ }`
	`113`	`+`
`84`	`114`	`/// <summary>`
`85`	`115`	`/// Implicitly converts an enumeration value to a <see cref="UnitKey" />.`
`86`	`116`	`/// </summary>`
`@@ -111,7 +141,7 @@ public static implicit operator UnitKey(Enum unit)`
`111`	`141`	`/// </remarks>`
`112`	`142`	`public static explicit operator Enum(UnitKey unitKey)`
`113`	`143`	`{`
`114`		`- return (Enum)Enum.ToObject(unitKey._unitType, unitKey._unitValue);`
	`144`	`+ return (Enum)Enum.ToObject(unitKey._unitEnumType, unitKey._unitEnumValue);`
`115`	`145`	`}`
`116`	`146`
`117`	`147`	`/// <summary>`
`@@ -129,25 +159,25 @@ public static explicit operator Enum(UnitKey unitKey)`
`129`	`159`	`/// </remarks>`
`130`	`160`	`public TUnit ToUnit<TUnit>() where TUnit : struct, Enum`
`131`	`161`	`{`
`132`		`- if (typeof(TUnit) != _unitType)`
	`162`	`+ if (typeof(TUnit) != _unitEnumType)`
`133`	`163`	`{`
`134`		`- throw new InvalidOperationException($"Cannot convert UnitKey of type {_unitType} to {typeof(TUnit)}.");`
	`164`	`+ throw new InvalidOperationException($"Cannot convert UnitKey of type {_unitEnumType} to {typeof(TUnit)}.");`
`135`	`165`	`}`
`136`	`166`
`137`		`- var unitValue = _unitValue;`
	`167`	`+ var unitValue = _unitEnumValue;`
`138`	`168`	`return Unsafe.As<int, TUnit>(ref unitValue);`
`139`	`169`	`}`
`140`	`170`
`141`	`171`	`private string GetDebuggerDisplay()`
`142`	`172`	`{`
`143`	`173`	`try`
`144`	`174`	`{`
`145`		`- var unitName = Enum.GetName(_unitType, _unitValue);`
`146`		`- return string.IsNullOrEmpty(unitName) ? $"{nameof(UnitType)}: {_unitType}, {nameof(UnitValue)} = {_unitValue}" : $"{_unitType.Name}.{unitName}";`
	`175`	`+ var unitName = Enum.GetName(_unitEnumType, _unitEnumValue);`
	`176`	`+ return string.IsNullOrEmpty(unitName) ? $"{nameof(UnitEnumType)}: {_unitEnumType}, {nameof(UnitEnumValue)} = {_unitEnumValue}" : $"{_unitEnumType.Name}.{unitName}";`
`147`	`177`	`}`
`148`	`178`	`catch`
`149`	`179`	`{`
`150`		`- return $"{nameof(UnitType)}: {_unitType}, {nameof(UnitValue)} = {_unitValue}";`
	`180`	`+ return $"{nameof(UnitEnumType)}: {_unitEnumType}, {nameof(UnitEnumValue)} = {_unitEnumValue}";`
`151`	`181`	`}`
`152`	`182`	`}`
`153`	`183`
`@@ -162,8 +192,8 @@ private string GetDebuggerDisplay()`
`162`	`192`	`/// </remarks>`
`163`	`193`	`public void Deconstruct(out Type unitType, out int unitValue)`
`164`	`194`	`{`
`165`		`- unitType = _unitType;`
`166`		`- unitValue = _unitValue;`
	`195`	`+ unitType = _unitEnumType;`
	`196`	`+ unitValue = _unitEnumValue;`
`167`	`197`	`}`
`168`	`198`
`169`	`199`	`#region Equality members`
`@@ -172,21 +202,21 @@ public void Deconstruct(out Type unitType, out int unitValue)`
`172`	`202`	`public bool Equals(UnitKey other)`
`173`	`203`	`{`
`174`	`204`	`// implementing the Equality members on net48 is 5x faster than the default`
`175`		`- return _unitType == other._unitType && _unitValue == other._unitValue;`
	`205`	`+ return _unitEnumType == other._unitEnumType && _unitEnumValue == other._unitEnumValue;`
`176`	`206`	`}`
`177`	`207`
`178`	`208`	`/// <inheritdoc />`
`179`	`209`	`public override int GetHashCode()`
`180`	`210`	`{`
`181`	`211`	`// implementing the Equality members on net48 is 5x faster than the default`
`182`		`- if (_unitType == null)`
	`212`	`+ if (_unitEnumType == null)`
`183`	`213`	`{`
`184`		`- return _unitValue;`
	`214`	`+ return _unitEnumValue;`
`185`	`215`	`}`
`186`	`216`
`187`	`217`	`unchecked`
`188`	`218`	`{`
`189`		`- return (_unitType.GetHashCode() * 397) ^ _unitValue;`
	`219`	`+ return (_unitEnumType.GetHashCode() * 397) ^ _unitEnumValue;`
`190`	`220`	`}`
`191`	`221`	`}`
`192`	`222`