replaced the public usages of the UnitKey constructor and improved the exception comments

Author: lipchev

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/CustomCode/UnitAbbreviationsCache.cs

@@ -116,7 +116,7 @@ public void MapUnitToAbbreviation<TUnitType>(TUnitType unit, params IEnumerable<
         /// <param name="abbreviations">Unit abbreviations to add.</param>
         public void MapUnitToAbbreviation(Type unitType, int unitValue, IFormatProvider? formatProvider, params IEnumerable<string> abbreviations)
         {
-            MapUnitToAbbreviation(new UnitKey(unitType, unitValue), formatProvider, abbreviations);
+            MapUnitToAbbreviation(UnitKey.Create(unitType, unitValue), formatProvider, abbreviations);
         }
 
         /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>>
@@ -159,6 +159,10 @@ public void MapUnitToAbbreviation(UnitKey unitKey, IFormatProvider? formatProvid
         /// <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>
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when no unit information is found for the specified
+        ///     <paramref name="unit" />.
+        /// </exception>
         public void MapUnitToDefaultAbbreviation<TUnitType>(TUnitType unit, string abbreviation)
             where TUnitType : struct, Enum
         {
@@ -189,9 +193,15 @@ public void MapUnitToDefaultAbbreviation<TUnitType>(TUnitType unit, IFormatProvi
         /// <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>
+        /// <exception cref="ArgumentNullException">
+        ///     Thrown when the provided type is null.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///     Thrown when the provided type is not an enumeration type.
+        /// </exception>
         public void MapUnitToDefaultAbbreviation(Type unitType, int unitValue, IFormatProvider? formatProvider, string abbreviation)
         {
-            MapUnitToDefaultAbbreviation(new UnitKey(unitType, unitValue), formatProvider, abbreviation);
+            MapUnitToDefaultAbbreviation(UnitKey.Create(unitType, unitValue), formatProvider, abbreviation);
         }
 
         /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>>
@@ -240,6 +250,12 @@ 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="ArgumentNullException">
+        ///     Thrown when the provided type is null.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///     Thrown when the provided type is not an enumeration type.
+        /// </exception>
         /// <exception cref="UnitNotFoundException">
         ///     Thrown when no unit information is found for the specified
         ///     <paramref name="unitType" /> and <paramref name="unitValue" />.
@@ -249,7 +265,7 @@ public string GetDefaultAbbreviation<TUnitType>(TUnitType unit, IFormatProvider?
         /// </exception>
         public string GetDefaultAbbreviation(Type unitType, int unitValue, IFormatProvider? formatProvider = null)
         {
-            return GetDefaultAbbreviation(new UnitKey(unitType, unitValue), formatProvider);
+            return GetDefaultAbbreviation(UnitKey.Create(unitType, unitValue), formatProvider);
         }
 
         /// <inheritdoc cref="GetDefaultAbbreviation{TUnitType}" />
@@ -297,13 +313,19 @@ public IReadOnlyList<string> GetUnitAbbreviations<TUnitType>(TUnitType unit, IFo
         /// <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="ArgumentNullException">
+        ///     Thrown when the provided type is null.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///     Thrown when the provided type is not an enumeration type.
+        /// </exception>
         /// <exception cref="UnitNotFoundException">
         ///     Thrown when no unit information is found for the specified
         ///     <paramref name="unitType" /> and <paramref name="unitValue" />.
         /// </exception>
         public IReadOnlyList<string> GetUnitAbbreviations(Type unitType, int unitValue, IFormatProvider? formatProvider = null)
         {
-            return GetUnitAbbreviations(new UnitKey(unitType, unitValue), formatProvider);
+            return GetUnitAbbreviations(UnitKey.Create(unitType, unitValue), formatProvider);
         }
 
         /// <summary>
@@ -336,19 +358,27 @@ public IReadOnlyList<string> GetUnitAbbreviations(UnitKey unitKey, IFormatProvid
         /// <returns>
         ///     A read-only list of unit abbreviations associated with the specified unit type.
         /// </returns>
+        /// <exception cref="ArgumentNullException">
+        ///     Thrown when the provided type is null.
+        /// </exception>
         /// <exception cref="ArgumentException">
-        ///     Thrown when the provided <paramref name="unitEnumType" /> is not an enum type.
+        ///     Thrown when the provided type is not an enumeration 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)
         {
+            if (unitEnumType == null)
+            {
+                throw new ArgumentNullException(nameof(unitEnumType));
+            }
+            
             if (!Quantities.TryGetQuantityByUnitType(unitEnumType, out QuantityInfo? quantityInfo))
             {
                 if (!unitEnumType.IsEnum)
                 {
-                    throw new ArgumentException($"Type {unitEnumType.FullName} is not a supported unit type.");
+                    throw new ArgumentException($"Unit type must be an enumeration, but was {unitEnumType.FullName}.", nameof(unitEnumType));
                 }
 
                 throw new UnitNotFoundException($"No quantity was found with the specified unit type: '{unitEnumType}'.") { Data = { ["unitType"] = unitEnumType.Name } };

UnitsNet/CustomCode/UnitKey.cs

@@ -105,7 +105,7 @@ public static UnitKey Create(Type unitType, int unitValue)
 
         if (!unitType.IsEnum)
         {
-            throw new ArgumentException($"Unit type must be an enumeration, but was {unitType.FullName}.");
+            throw new ArgumentException($"Unit type must be an enumeration, but was {unitType.FullName}.", nameof(unitType));
         }
 
         return new UnitKey(unitType, unitValue);