Make typed GetUnitInfo overload return UnitInfo<TQuantity, TUnit>

Replaces the IQuantity<TUnit> -> UnitInfo<TUnit> overload with
IQuantity<TQuantity, TUnit> -> UnitInfo<TQuantity, TUnit>, so the
typed extension returns the most specific UnitInfo shape when the
caller has a concretely-typed quantity (e.g. Length).

Behavior:
- Length q; q.GetUnitInfo() -> UnitInfo<Length, LengthUnit>
- IQuantity q; q.GetUnitInfo() -> UnitInfo (non-generic fallback)
- IQuantity<TUnit> q; q.GetUnitInfo() -> UnitInfo (non-generic fallback)

The IQuantity<TUnit> reference case loses its typed UnitInfo<TUnit>
return, but that scenario is uncommon compared to the concretely-typed
receiver case which now returns the richer UnitInfo<TQuantity, TUnit>.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: angularsen

UnitsNet.Tests/CustomCode/IQuantityTests.cs

@@ -82,16 +82,31 @@ public void GetUnitInfo_Zero_ReturnsBaseUnitInfo()
     }
 
     [Fact]
-    public void GetUnitInfo_TypedQuantity_ReturnsTypedUnitInfo()
+    public void GetUnitInfo_ConcreteQuantity_ReturnsFullyTypedUnitInfo()
     {
-        IQuantity<LengthUnit> quantity = new Length(3.0, LengthUnit.Centimeter);
+        var quantity = new Length(3.0, LengthUnit.Centimeter);
 
-        UnitInfo<LengthUnit> unitInfo = quantity.GetUnitInfo();
+        // Overload resolution picks GetUnitInfo<TQuantity, TUnit> for the concrete struct receiver,
+        // returning the most specific UnitInfo<Length, LengthUnit>.
+        UnitInfo<Length, LengthUnit> unitInfo = quantity.GetUnitInfo();
 
         Assert.Equal(LengthUnit.Centimeter, unitInfo.Value);
         Assert.Equal(nameof(LengthUnit.Centimeter), unitInfo.Name);
     }
 
+    [Fact]
+    public void GetUnitInfo_TypedQuantityReference_FallsBackToNonGeneric()
+    {
+        IQuantity<LengthUnit> quantity = new Length(3.0, LengthUnit.Centimeter);
+
+        // The IQuantity<TUnit> reference does not satisfy the IQuantity<TSelf, TUnit> constraint
+        // (TSelf would be IQuantity<MassUnit>), so resolution falls back to GetUnitInfo(IQuantity).
+        UnitInfo unitInfo = quantity.GetUnitInfo();
+
+        Assert.Equal(LengthUnit.Centimeter, ((UnitInfo<LengthUnit>)unitInfo).Value);
+        Assert.Equal(nameof(LengthUnit.Centimeter), unitInfo.Name);
+    }
+
     [Fact]
     public void GetUnitInfo_MatchesUnit()
     {

UnitsNet/Extensions/QuantityExtensions.cs

@@ -14,6 +14,12 @@ public static class QuantityExtensions
     /// <summary>
     ///     Gets the <see cref="UnitInfo"/> for the unit this quantity was constructed with.
     /// </summary>
+    /// <remarks>
+    ///     Picked by overload resolution for callers that only have an <see cref="IQuantity"/> reference.
+    ///     Concretely-typed callers (e.g. a <c>Mass</c> receiver) bind to the
+    ///     <see cref="GetUnitInfo{TQuantity,TUnit}(IQuantity{TQuantity,TUnit})"/> overload and get the
+    ///     more specific <see cref="UnitInfo{TQuantity,TUnit}"/> return.
+    /// </remarks>
     /// <param name="quantity">The quantity.</param>
     /// <returns>The <see cref="UnitInfo"/> for the quantity's unit.</returns>
     public static UnitInfo GetUnitInfo(this IQuantity quantity)
@@ -22,12 +28,20 @@ public static UnitInfo GetUnitInfo(this IQuantity quantity)
     }
 
     /// <summary>
-    ///     Gets the <see cref="UnitInfo{TUnit}"/> for the unit this quantity was constructed with.
+    ///     Gets the <see cref="UnitInfo{TQuantity,TUnit}"/> for the unit this quantity was constructed with.
     /// </summary>
+    /// <remarks>
+    ///     Picked by overload resolution for concretely-typed receivers (e.g. <c>Mass</c>) where C# can
+    ///     infer both <typeparamref name="TQuantity"/> and <typeparamref name="TUnit"/> from the receiver's
+    ///     <see cref="IQuantity{TSelf,TUnit}"/> implementation. Callers with only an <see cref="IQuantity"/>
+    ///     reference fall back to the non-generic <see cref="GetUnitInfo(IQuantity)"/> overload.
+    /// </remarks>
+    /// <typeparam name="TQuantity">The quantity type.</typeparam>
     /// <typeparam name="TUnit">The unit enum type.</typeparam>
     /// <param name="quantity">The quantity.</param>
-    /// <returns>The <see cref="UnitInfo{TUnit}"/> for the quantity's unit.</returns>
-    public static UnitInfo<TUnit> GetUnitInfo<TUnit>(this IQuantity<TUnit> quantity)
+    /// <returns>The <see cref="UnitInfo{TQuantity,TUnit}"/> for the quantity's unit.</returns>
+    public static UnitInfo<TQuantity, TUnit> GetUnitInfo<TQuantity, TUnit>(this IQuantity<TQuantity, TUnit> quantity)
+        where TQuantity : IQuantity<TQuantity, TUnit>
         where TUnit : struct, Enum
     {
         return quantity.QuantityInfo[quantity.Unit];