🎉Add new NumberExtensionsCS14 nuget package (#1620)

Fixes #1619

Add new project `NumberExtensionsCS14` to use the C#14 feature
`extension members` for making `5.Meters` work.

Please merge after C#14 is officially released.

---------

Co-authored-by: Andreas Gullberg Larsen <[email protected]>
Co-authored-by: Claude <[email protected]>

Author: 3 people

Build/build-functions.psm1

@@ -90,6 +90,7 @@ function Start-Tests {
   $projectPaths = @(
     "UnitsNet.Tests\UnitsNet.Tests.csproj",
     "UnitsNet.NumberExtensions.Tests\UnitsNet.NumberExtensions.Tests.csproj",
+    "UnitsNet.NumberExtensions.CS14.Tests\UnitsNet.NumberExtensions.CS14.Tests.csproj",
     "UnitsNet.Serialization.JsonNet.Tests\UnitsNet.Serialization.JsonNet.Tests.csproj"
     )
 
@@ -129,7 +130,8 @@ function Start-PackNugets {
   $projectPaths = @(
     "UnitsNet\UnitsNet.csproj",
     "UnitsNet.Serialization.JsonNet\UnitsNet.Serialization.JsonNet.csproj",
-    "UnitsNet.NumberExtensions\UnitsNet.NumberExtensions.csproj"
+    "UnitsNet.NumberExtensions\UnitsNet.NumberExtensions.csproj",
+    "UnitsNet.NumberExtensions.CS14\UnitsNet.NumberExtensions.CS14.csproj"
     )
 
   write-host -foreground blue "Pack nugets (dotnet CLI)...`n---"

CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14Generator.cs

@@ -0,0 +1,82 @@
+using System;
+using CodeGen.JsonTypes;
+
+namespace CodeGen.Generators.UnitsNetGen
+{
+    internal class NumberExtensionsCS14Generator(Quantity quantity) : GeneratorBase
+    {
+        private readonly Quantity _quantity = quantity ?? throw new ArgumentNullException(nameof(quantity));
+        private readonly Unit[] _units = quantity.Units;
+        private readonly string _quantityName = quantity.Name;
+
+        public string Generate()
+        {
+            Writer.WL(GeneratedFileHeader);
+
+            Writer.WL(
+                $@"
+using System;
+
+#if NET7_0_OR_GREATER
+using System.Numerics;
+#endif
+
+#nullable enable
+
+namespace UnitsNet.NumberExtensions.NumberTo{_quantityName}
+{{
+    /// <summary>
+    /// A number to {_quantityName} Extensions
+    /// </summary>");
+
+            Writer.WLIfText(1, GetObsoleteAttributeOrNull(_quantity));
+            Writer.WL(@$"
+    public static class NumberTo{_quantityName}Extensions
+    {{");
+
+            Writer.WL(@"
+#pragma warning disable CS1591
+        extension<T>(T value)
+#pragma warning restore CS1591
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+#else
+            , IConvertible
+#endif
+        {");
+
+
+            foreach (var unit in _units)
+            {
+                if (unit.SkipConversionGeneration)
+                    continue;
+
+                Writer.WL(3, $@"
+/// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(double)"" />");
+
+                // Include obsolete text from the quantity per extension method, to make it visible when the class is not explicitly referenced in code.
+                Writer.WLIfText(3, GetObsoleteAttributeOrNull(unit.ObsoleteText ?? _quantity.ObsoleteText));
+
+                Writer.WL(3, $@"public {_quantityName} {unit.PluralName}
+#if NET7_0_OR_GREATER
+                => {_quantityName}.From{unit.PluralName}(double.CreateChecked(value));
+#else
+                => {_quantityName}.From{unit.PluralName}(value.ToDouble(null));
+#endif
+");
+            }
+
+            Writer.WL(2, @"}
+    }
+}");
+            return Writer.ToString();
+        }
+
+        /// <inheritdoc cref="GetObsoleteAttributeOrNull(string)"/>
+        private static string? GetObsoleteAttributeOrNull(Quantity quantity) => GetObsoleteAttributeOrNull(quantity.ObsoleteText);
+
+        private static string? GetObsoleteAttributeOrNull(string? obsoleteText) =>
+            string.IsNullOrWhiteSpace(obsoleteText) ? null : $"[Obsolete(\"{obsoleteText}\")]";
+    }
+}

CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14TestClassGenerator.cs

@@ -0,0 +1,51 @@
+using System;
+using CodeGen.JsonTypes;
+
+namespace CodeGen.Generators.UnitsNetGen
+{
+    internal class NumberExtensionsCS14TestClassGenerator : GeneratorBase
+    {
+        private readonly Unit[] _units;
+        private readonly string _quantityName;
+
+        public NumberExtensionsCS14TestClassGenerator(Quantity quantity)
+        {
+            if (quantity is null) throw new ArgumentNullException(nameof(quantity));
+
+            _units = quantity.Units;
+            _quantityName = quantity.Name;
+        }
+
+        public string Generate()
+        {
+            Writer.WL(GeneratedFileHeader);
+
+            Writer.WL(
+$@"
+using UnitsNet.NumberExtensions.NumberTo{_quantityName};
+using Xunit;
+
+namespace UnitsNet.Tests
+{{
+    public class NumberTo{_quantityName}ExtensionsTests
+    {{");
+
+            foreach (var unit in _units)
+            {
+                if (unit.SkipConversionGeneration)
+                    continue;
+
+                Writer.WL(2, $@"
+[Fact]");
+
+                Writer.WL(2, $@"public void NumberTo{unit.PluralName}Test() =>
+            Assert.Equal({_quantityName}.From{unit.PluralName}(2), 2.{unit.PluralName});
+");
+            }
+
+            Writer.WL(1, @"}
+}");
+            return Writer.ToString();
+        }
+    }
+}

CodeGen/Generators/UnitsNetGenerator.cs

@@ -39,13 +39,17 @@ public static void Generate(string rootDir, Quantity[] quantities, QuantityNameT
             var outputDir = $"{rootDir}/UnitsNet/GeneratedCode";
             var extensionsOutputDir = $"{rootDir}/UnitsNet.NumberExtensions/GeneratedCode";
             var extensionsTestOutputDir = $"{rootDir}/UnitsNet.NumberExtensions.Tests/GeneratedCode";
+            var extensionsCs14OutputDir = $"{rootDir}/UnitsNet.NumberExtensions.CS14/GeneratedCode";
+            var extensionsCs14TestOutputDir = $"{rootDir}/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode";
             var testProjectDir = $"{rootDir}/UnitsNet.Tests";
 
             // Ensure output directories exist
             Directory.CreateDirectory($"{outputDir}/Quantities");
             Directory.CreateDirectory($"{outputDir}/Units");
             Directory.CreateDirectory($"{extensionsOutputDir}");
             Directory.CreateDirectory($"{extensionsTestOutputDir}");
+            Directory.CreateDirectory($"{extensionsCs14OutputDir}");
+            Directory.CreateDirectory($"{extensionsCs14TestOutputDir}");
             Directory.CreateDirectory($"{testProjectDir}/GeneratedCode");
             Directory.CreateDirectory($"{testProjectDir}/GeneratedCode/TestsBase");
             Directory.CreateDirectory($"{testProjectDir}/GeneratedCode/QuantityTests");
@@ -58,6 +62,8 @@ public static void Generate(string rootDir, Quantity[] quantities, QuantityNameT
                 GenerateUnitType(quantity, $"{outputDir}/Units/{quantity.Name}Unit.g.cs", unitEnumValues);
                 GenerateNumberToExtensions(quantity, $"{extensionsOutputDir}/NumberTo{quantity.Name}Extensions.g.cs");
                 GenerateNumberToExtensionsTestClass(quantity, $"{extensionsTestOutputDir}/NumberTo{quantity.Name}ExtensionsTest.g.cs");
+                GenerateNumberToExtensionsCS14(quantity, $"{extensionsCs14OutputDir}/NumberTo{quantity.Name}Extensions.g.cs");
+                GenerateNumberToExtensionsCS14TestClass(quantity, $"{extensionsCs14TestOutputDir}/NumberTo{quantity.Name}ExtensionsTest.g.cs");
 
                 // Example: CustomCode/Quantities/LengthTests inherits GeneratedCode/TestsBase/LengthTestsBase
                 // This way when new units are added to the quantity JSON definition, we auto-generate the new
@@ -107,6 +113,18 @@ private static void GenerateNumberToExtensionsTestClass(Quantity quantity, strin
             File.WriteAllText(filePath, content);
         }
 
+        private static void GenerateNumberToExtensionsCS14(Quantity quantity, string filePath)
+        {
+            var content = new NumberExtensionsCS14Generator(quantity).Generate();
+            File.WriteAllText(filePath, content);
+        }
+
+        private static void GenerateNumberToExtensionsCS14TestClass(Quantity quantity, string filePath)
+        {
+            var content = new NumberExtensionsCS14TestClassGenerator(quantity).Generate();
+            File.WriteAllText(filePath, content);
+        }
+
         private static void GenerateUnitType(Quantity quantity, string filePath, UnitEnumNameToValue unitEnumValues)
         {
             var content = new UnitTypeGenerator(quantity, unitEnumValues).Generate();

README.md

@@ -45,11 +45,49 @@ dotnet add package UnitsNet
 
 or go to [NuGet Gallery | UnitsNet](https://www.nuget.org/packages/UnitsNet) for detailed instructions.
 
-#### Build Targets
+### Build Targets
 
 * .NET Standard 2.0
+* .NET 8.0 (LTS)
+* .NET 9.0 (latest stable)
+* .NET 10.0 (preview)
 * [.NET nanoFramework](https://www.nanoframework.net/)
 
+
+### Extension Packages
+
+#### UnitsNet.NumberExtensions.CS14 (C# 14 Extension Members)
+
+For C# 14 projects, use the new extension members syntax (no parentheses):
+
+```bash
+dotnet add package UnitsNet.NumberExtensions.CS14
+```
+
+```C#
+using UnitsNet.NumberExtensions.NumberToLength;
+
+// C# 14 extension members syntax, without parantheses
+Length distance = 5.Meters;        // Instead of Length.FromMeters(5)
+```
+
+> **Note:** Requires '<LangVersion>preview</LangVersion>' and .NET 10 SDK preview for now.
+
+#### UnitsNet.NumberExtensions (Classic)
+
+For C# 13 and lower (.NET SDK 9 or lower), use the classic extension methods:
+
+```bash
+dotnet add package UnitsNet.NumberExtensions
+```
+
+```C#
+using UnitsNet.NumberExtensions.NumberToLength;
+
+// Classic extension methods, with parentheses
+Length distance = 5.Meters();        // Instead of Length.FromMeters(5)
+```
+
 ### Static Typing
 
 ```C#