1.1.0

.woodpecker/main.yml

@@ -0,0 +1,20 @@
+variables:
+  - &image mcr.microsoft.com/dotnet/sdk:8.0-jammy
+steps:
+  build:
+    image: *image
+    commands: dotnet build
+  test:
+    image: *image
+    commands: dotnet test --collect:"XPlat Code Coverage"
+  pack:
+    image: *image
+    commands: dotnet pack --version-suffix ci.$CI_PIPELINE_NUMBER
+  publish:
+    image: *image
+    when:
+      branch: main
+      event: push
+    commands: dotnet nuget push -s https://nuget.ellpeck.de/v3/index.json **/*.nupkg -k $BAGET_KEY -n
+    secrets:
+      - baget_key

DynamicEnums/DynamicEnum.cs

@@ -105,9 +105,9 @@ namespace DynamicEnums {
         /// <returns>The newly created enum value</returns>
         /// <exception cref="ArgumentException">Thrown if the name or value passed are already present</exception>
         public static T Add<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
             T>(string name, BigInteger value) where T : DynamicEnum {
             var storage = DynamicEnum.GetStorage(typeof(T));
 
@@ -135,9 +135,9 @@ namespace DynamicEnums {
         /// <typeparam name="T">The type to add this value to</typeparam>
         /// <returns>The newly created enum value</returns>
         public static T AddValue<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
             T>(string name) where T : DynamicEnum {
             BigInteger value = 0;
             while (DynamicEnum.IsDefined(typeof(T), value))
@@ -154,9 +154,9 @@ namespace DynamicEnums {
         /// <typeparam name="T">The type to add this value to</typeparam>
         /// <returns>The newly created enum value</returns>
         public static T AddFlag<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
             T>(string name) where T : DynamicEnum {
             BigInteger value = 1;
             while (DynamicEnum.IsDefined(typeof(T), value))
@@ -207,9 +207,9 @@ namespace DynamicEnums {
         /// <typeparam name="T">The type of enum.</typeparam>
         /// <returns>All of the unique flags that make up <paramref name="combinedFlag"/>.</returns>
         public static IEnumerable<T> GetUniqueFlags<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
             T>(T combinedFlag) where T : DynamicEnum {
             // we can't use the same method here as EnumHelper.GetUniqueFlags since DynamicEnum doesn't guarantee sorted values
             var max = DynamicEnum.GetValues<T>().Max(DynamicEnum.GetValue);
@@ -232,9 +232,9 @@ namespace DynamicEnums {
         /// <typeparam name="T">The type of the values</typeparam>
         /// <returns>The bitwise OR (|) combination</returns>
         public static T Or<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
             T>(T left, T right) where T : DynamicEnum {
             var cache = DynamicEnum.GetStorage(typeof(T)).OrCache;
             if (!cache.TryGetValue((left, right), out var ret)) {
@@ -252,9 +252,9 @@ namespace DynamicEnums {
         /// <typeparam name="T">The type of the values</typeparam>
         /// <returns>The bitwise AND (&amp;) combination</returns>
         public static T And<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
             T>(T left, T right) where T : DynamicEnum {
             var cache = DynamicEnum.GetStorage(typeof(T)).AndCache;
             if (!cache.TryGetValue((left, right), out var ret)) {
@@ -272,9 +272,9 @@ namespace DynamicEnums {
         /// <typeparam name="T">The type of the values</typeparam>
         /// <returns>The bitwise XOR (^) combination</returns>
         public static T Xor<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
             T>(T left, T right) where T : DynamicEnum {
             var cache = DynamicEnum.GetStorage(typeof(T)).XorCache;
             if (!cache.TryGetValue((left, right), out var ret)) {
@@ -291,9 +291,9 @@ namespace DynamicEnums {
         /// <typeparam name="T">The type of the values</typeparam>
         /// <returns>The bitwise NEG (~) value</returns>
         public static T Neg<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
             T>(T value) where T : DynamicEnum {
             var cache = DynamicEnum.GetStorage(typeof(T)).NegCache;
             if (!cache.TryGetValue(value, out var ret)) {
@@ -319,9 +319,9 @@ namespace DynamicEnums {
         /// <typeparam name="T">The type that the returned dynamic enum should have</typeparam>
         /// <returns>The defined or combined dynamic enum value</returns>
         public static T GetEnumValue<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
             T>(BigInteger value) where T : DynamicEnum {
             return (T) DynamicEnum.GetEnumValue(typeof(T), value);
         }
@@ -333,9 +333,9 @@ namespace DynamicEnums {
         /// <param name="value">The value whose dynamic enum value to get</param>
         /// <returns>The defined or combined dynamic enum value</returns>
         public static DynamicEnum GetEnumValue(
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
             Type type, BigInteger value) {
             var storage = DynamicEnum.GetStorage(type);
 
@@ -360,9 +360,9 @@ namespace DynamicEnums {
         /// <typeparam name="T">The type of the dynamic enum value to parse</typeparam>
         /// <returns>The parsed enum value, or null if parsing fails</returns>
         public static T Parse<
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
             T>(string strg) where T : DynamicEnum {
             return (T) DynamicEnum.Parse(typeof(T), strg);
         }
@@ -376,9 +376,9 @@ namespace DynamicEnums {
         /// <param name="strg">The string to parse into a dynamic enum value</param>
         /// <returns>The parsed enum value, or null if parsing fails</returns>
         public static DynamicEnum Parse(
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
             Type type, string strg) {
             var cache = DynamicEnum.GetStorage(type).ParseCache;
             if (!cache.TryGetValue(strg, out var cached)) {
@@ -428,9 +428,9 @@ namespace DynamicEnums {
         }
 
         private static DynamicEnum Construct(
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-            #endif
+#endif
             Type type, string name, BigInteger value) {
             return (DynamicEnum) Activator.CreateInstance(type, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new object[] {name, value}, CultureInfo.InvariantCulture);
         }

DynamicEnums/DynamicEnums.csproj

@@ -1,8 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
-        <TargetFrameworks>net452;netstandard2.0;net6.0</TargetFrameworks>
+        <TargetFrameworks>net452;netstandard2.0;net8.0</TargetFrameworks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
-        <IsTrimmable>true</IsTrimmable>
+        <IsAotCompatible Condition="'$(TargetFramework)'=='net8.0'">true</IsAotCompatible>
     </PropertyGroup>
 
     <PropertyGroup>
@@ -13,7 +13,7 @@
         <RepositoryUrl>https://github.com/Ellpeck/DynamicEnums</RepositoryUrl>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <PackageReadmeFile>README.md</PackageReadmeFile>
-        <VersionPrefix>1.0.1</VersionPrefix>
+        <VersionPrefix>1.1.0</VersionPrefix>
     </PropertyGroup>
 
     <ItemGroup>

DynamicEnums/EnumHelper.cs

@@ -14,11 +14,11 @@ namespace DynamicEnums {
         /// <typeparam name="T">The type whose enum to get</typeparam>
         /// <returns>An enumerable of the values of the enum, in declaration order.</returns>
         public static T[] GetValues<T>() where T : struct, Enum {
-            #if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
             return Enum.GetValues<T>();
-            #else
+#else
             return (T[]) Enum.GetValues(typeof(T));
-            #endif
+#endif
         }
 
         /// <summary>

Jenkinsfile

@@ -1,35 +0,0 @@
-pipeline {
-  agent any
-  stages {
-    stage('Test') {
-      steps {
-        sh 'dotnet test --collect:"XPlat Code Coverage"'
-      }
-    }
-
-    stage('Pack') {
-      steps {
-        sh 'find . -type f -name "*.nupkg" -delete'
-        sh 'dotnet pack --version-suffix ${BUILD_NUMBER}'
-      }
-    }
-
-    stage('Publish') {
-      when {
-        branch 'main'
-      }
-      steps {
-        sh 'dotnet nuget push -s https://nuget.ellpeck.de/v3/index.json **/*.nupkg -k $BAGET -n'
-      }
-    }
-  }
-  post {
-    always {
-      nunit testResultsPattern: '**/TestResults.xml'
-      cobertura coberturaReportFile: '**/coverage.cobertura.xml'
-    }
-  }
-  environment {
-    BAGET = credentials('3db850d0-e6b5-43d5-b607-d180f4eab676')
-  }
-}

Tests/Tests.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
-        <TargetFramework>net6.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
         <VSTestLogger>nunit</VSTestLogger>
         <IsPackable>false</IsPackable>
     </PropertyGroup>