Update projects for .NET 8.0 and 9.0 support (#648)

falvarez1 · pbhal · web-flow · commit 5dd85b4d3479 · 2025-01-30T10:48:34.000+05:30
* Update projects for .NET 8.0 and 9.0 support

- Added BenchmarkDotNet attributes in Program.cs for .NET 8.0 and 9.0.
- Updated RulesEngineBenchmark.csproj to target .NET 8.0 and 9.0; upgraded BenchmarkDotNet to 0.14.0.
- Modified DemoApp.EFDataExample.csproj to target .NET 8.0 and 9.0; upgraded EF Core packages to 9.0.1.
- Changed DemoApp.csproj to target .NET 8.0 and 9.0, preserving project references and workflow files.
- Updated global.json to specify SDK version 9.0.0.
- Modified RulesEngine.csproj to target .NET 9.0 and updated package references, including System.Text.Json.
- Updated RulesEngine.UnitTest.csproj to target .NET 8.0 and 9.0; upgraded testing libraries and System.Text.Json.

* re-introduced net6.0 support

* update AutoFixture to fix vulnerabilities

* add JsonElement support to fix error in the DemoApp

---------

Co-authored-by: Purunjay Bhal &lt;purunjaybhal@microsoft.com&gt;
diff --git a/benchmark/RulesEngineBenchmark/Program.cs b/benchmark/RulesEngineBenchmark/Program.cs
@@ -7,12 +7,16 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using BenchmarkDotNet.Jobs;
+using System.Text.Json;
 
 namespace RulesEngineBenchmark
 {
-    using System.Text.Json;
 
     [MemoryDiagnoser]
+    [SimpleJob(RuntimeMoniker.Net60)]
+    [SimpleJob(RuntimeMoniker.Net80)]
+    [SimpleJob(RuntimeMoniker.Net90)]
     public class REBenchmark
     {
         private readonly RulesEngine.RulesEngine rulesEngine;
diff --git a/benchmark/RulesEngineBenchmark/RulesEngineBenchmark.csproj b/benchmark/RulesEngineBenchmark/RulesEngineBenchmark.csproj
@@ -2,16 +2,16 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net6.0;net8.0;net9.0</TargetFrameworks>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.12" />
-	<!--<PackageReference Include="RulesEngine" Version="3.0.2" />-->
+    <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
+    <!--<PackageReference Include="RulesEngine" Version="3.0.2" />-->
   </ItemGroup>
 
   <ItemGroup>
-     <ProjectReference Include="..\..\src\RulesEngine\RulesEngine.csproj" /> 
+    <ProjectReference Include="..\..\src\RulesEngine\RulesEngine.csproj" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/demo/DemoApp.EFDataExample/DemoApp.EFDataExample.csproj b/demo/DemoApp.EFDataExample/DemoApp.EFDataExample.csproj
@@ -1,14 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
     <RootNamespace>DemoApp.EFDataExample</RootNamespace>
     <AssemblyName>DemoApp.EFDataExample</AssemblyName>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.1" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="8.0.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/demo/DemoApp/DemoApp.csproj b/demo/DemoApp/DemoApp.csproj
@@ -2,15 +2,15 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
     <StartupObject>DemoApp.Program</StartupObject>
   </PropertyGroup>
 
   <ItemGroup>
     <ProjectReference Include="../../src/RulesEngine/RulesEngine.csproj" />
     <ProjectReference Include="..\DemoApp.EFDataExample\DemoApp.EFDataExample.csproj" />
   </ItemGroup>
-  
+
   <ItemGroup>
     <None Update="Workflows\Discount.json">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
diff --git a/global.json b/global.json
@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "8.0.0",
+    "version": "9.0.0",
     "rollForward": "latestFeature",
     "allowPrerelease": false
   }
diff --git a/src/RulesEngine/HelperFunctions/Utils.cs b/src/RulesEngine/HelperFunctions/Utils.cs
@@ -26,39 +26,46 @@ public static object GetTypedObject(dynamic input)
         }
         public static Type CreateAbstractClassType(dynamic input)
         {
-            List<DynamicProperty> props = new List<DynamicProperty>();
+            List<DynamicProperty> props = [];
 
-            if (input == null)
+            if (input is System.Text.Json.JsonElement jsonElement)
+            {
+                if (jsonElement.ValueKind == System.Text.Json.JsonValueKind.Null)
+                {
+                    return typeof(object);
+                }
+            }
+            else if (input == null)
             {
                 return typeof(object);
             }
-            if (!(input is ExpandoObject))
+
+            if (input is not ExpandoObject expandoObject)
             {
                 return input.GetType();
             }
 
-            else
+            foreach (var expando in expandoObject)
             {
-                foreach (var expando in (IDictionary<string, object>)input)
+                Type value;
+                if (expando.Value is IList list)
                 {
-                    Type value;
-                    if (expando.Value is IList)
+                    if (list.Count == 0)
                     {
-                        if (((IList)expando.Value).Count == 0)
-                            value = typeof(List<object>);
-                        else
-                        {
-                            var internalType = CreateAbstractClassType(((IList)expando.Value)[0]);
-                            value = new List<object>().Cast(internalType).ToList(internalType).GetType();
-                        }
-
+                        value = typeof(List<object>);
                     }
                     else
                     {
-                        value = CreateAbstractClassType(expando.Value);
+                        var internalType = CreateAbstractClassType(list[0]);
+                        value = new List<object>().Cast(internalType).ToList(internalType).GetType();
                     }
-                    props.Add(new DynamicProperty(expando.Key, value));
+
+                }
+                else
+                {
+                    value = CreateAbstractClassType(expando.Value);
                 }
+                props.Add(new DynamicProperty(expando.Key, value));
             }
 
             var type = DynamicClassFactory.CreateType(props);
@@ -67,15 +74,15 @@ public static Type CreateAbstractClassType(dynamic input)
 
         public static object CreateObject(Type type, dynamic input)
         {
-            if (!(input is ExpandoObject))
+            if (input is not ExpandoObject expandoObject)
             {
                 return Convert.ChangeType(input, type);
             }
-            object obj = Activator.CreateInstance(type);
+            var obj = Activator.CreateInstance(type);
 
             var typeProps = type.GetProperties().ToDictionary(c => c.Name);
 
-            foreach (var expando in (IDictionary<string, object>)input)
+            foreach (var expando in expandoObject)
             {
                 if (typeProps.ContainsKey(expando.Key) &&
                     expando.Value != null && (expando.Value.GetType().Name != "DBNull" || expando.Value != DBNull.Value))
@@ -87,14 +94,13 @@ public static object CreateObject(Type type, dynamic input)
                         var propType = propInfo.PropertyType;
                         val = CreateObject(propType, expando.Value);
                     }
-                    else if (expando.Value is IList)
+                    else if (expando.Value is IList temp)
                     {
                         var internalType = propInfo.PropertyType.GenericTypeArguments.FirstOrDefault() ?? typeof(object);
-                        var temp = (IList)expando.Value;
                         var newList = new List<object>().Cast(internalType).ToList(internalType);
-                        for (int i = 0; i < temp.Count; i++)
+                        foreach (var t in temp)
                         {
-                            var child = CreateObject(internalType, temp[i]);
+                            var child = CreateObject(internalType, t);
                             newList.Add(child);
                         };
                         val = newList;
diff --git a/src/RulesEngine/RulesEngine.csproj b/src/RulesEngine/RulesEngine.csproj
@@ -1,15 +1,16 @@
-<Project Sdk="Microsoft.NET.Sdk">
+﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net8.0;net6.0;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>net6.0;net8.0;net9.0;netstandard2.0</TargetFrameworks>
+    <LangVersion>13.0</LangVersion>
     <Version>5.0.4</Version>
     <Copyright>Copyright (c) Microsoft Corporation.</Copyright>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <PackageProjectUrl>https://github.com/microsoft/RulesEngine</PackageProjectUrl>
     <Authors>Abbas Cyclewala</Authors>
     <Description>Rules Engine is a package for abstracting business logic/rules/policies out of the system. This works in a very simple way by giving you an ability to put your rules in a store outside the core logic of the system thus ensuring that any change in rules doesn't affect the core system.</Description>
-	  <PackageReleaseNotes>https://github.com/microsoft/RulesEngine/blob/main/CHANGELOG.md</PackageReleaseNotes>
-	  <PackageTags>BRE, Rules Engine, Abstraction</PackageTags>
+    <PackageReleaseNotes>https://github.com/microsoft/RulesEngine/blob/main/CHANGELOG.md</PackageReleaseNotes>
+    <PackageTags>BRE, Rules Engine, Abstraction</PackageTags>
     <PackageReadmeFile>README.md</PackageReadmeFile>
   </PropertyGroup>
 
@@ -33,27 +34,27 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="FastExpressionCompiler" Version="4.1.0" />
-    <PackageReference Include="FluentValidation" Version="11.9.0" />
-
-    <PackageReference Include="System.Linq.Dynamic.Core" Version="1.6.0" />
-
+    <PackageReference Include="FastExpressionCompiler" Version="5.0.2" />
+    <PackageReference Include="FluentValidation" Version="11.11.0" />
+    <PackageReference Include="System.Linq.Dynamic.Core" Version="1.6.0.1" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All" />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetFramework)' == 'net6.0'">
-    <PackageReference Include="System.Text.Json" Version="8.0.0" />
-  </ItemGroup>
+  <Choose>
+    <When Condition="'$(TargetFramework)' == 'net6.0' or '$(TargetFramework)' == 'netstandard2.0'">
+      <ItemGroup>
+        <PackageReference Include="System.Text.Json" Version="6.0.11" />
+      </ItemGroup>
+    </When>
+    <Otherwise>
+      <ItemGroup>
+        <PackageReference Include="System.Text.Json" Version="9.0.1" />
+      </ItemGroup>
+    </Otherwise>
+  </Choose>
 
-  <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
-    <PackageReference Include="System.Text.Json" Version="8.0.0" />
-  </ItemGroup>
-  
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
-
-    <PackageReference Include="System.Text.Json" Version="8.0.0" />
     <PackageReference Include="Microsoft.CSharp" Version="4.7.0"/>
-
   </ItemGroup>
 
 </Project>
diff --git a/test/RulesEngine.UnitTest/RulesEngine.UnitTest.csproj b/test/RulesEngine.UnitTest/RulesEngine.UnitTest.csproj
@@ -1,21 +1,21 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net6.0;net8.0;net9.0</TargetFrameworks>
     <SignAssembly>True</SignAssembly>
     <AssemblyOriginatorKeyFile>..\..\signing\RulesEngine-publicKey.snk</AssemblyOriginatorKeyFile>
     <DelaySign>True</DelaySign>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="AutoFixture" Version="4.18.1" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Include="Moq" Version="4.20.70" />
-    <PackageReference Include="System.Text.Json" Version="8.0.4" />
-    <PackageReference Include="xunit" Version="2.6.5" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.6">
+    <PackageReference Include="AutoFixture" Version="5.0.0-preview0012" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="System.Text.Json" Version="9.0.1" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="6.0.0">
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"sdk": {`
`3`		`- "version": "8.0.0",`
	`3`	`+ "version": "9.0.0",`
`4`	`4`	`"rollForward": "latestFeature",`
`5`	`5`	`"allowPrerelease": false`
`6`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,39 +26,46 @@ public static object GetTypedObject(dynamic input)`
`26`	`26`	`}`
`27`	`27`	`public static Type CreateAbstractClassType(dynamic input)`
`28`	`28`	`{`
`29`		`- List<DynamicProperty> props = new List<DynamicProperty>();`
	`29`	`+ List<DynamicProperty> props = [];`
`30`	`30`
`31`		`- if (input == null)`
	`31`	`+ if (input is System.Text.Json.JsonElement jsonElement)`
	`32`	`+ {`
	`33`	`+ if (jsonElement.ValueKind == System.Text.Json.JsonValueKind.Null)`
	`34`	`+ {`
	`35`	`+ return typeof(object);`
	`36`	`+ }`
	`37`	`+ }`
	`38`	`+ else if (input == null)`
`32`	`39`	`{`
`33`	`40`	`return typeof(object);`
`34`	`41`	`}`
`35`		`- if (!(input is ExpandoObject))`
	`42`	`+`
	`43`	`+ if (input is not ExpandoObject expandoObject)`
`36`	`44`	`{`
`37`	`45`	`return input.GetType();`
`38`	`46`	`}`
`39`	`47`
`40`		`- else`
	`48`	`+ foreach (var expando in expandoObject)`
`41`	`49`	`{`
`42`		`- foreach (var expando in (IDictionary<string, object>)input)`
	`50`	`+ Type value;`
	`51`	`+ if (expando.Value is IList list)`
`43`	`52`	`{`
`44`		`- Type value;`
`45`		`- if (expando.Value is IList)`
	`53`	`+ if (list.Count == 0)`
`46`	`54`	`{`
`47`		`- if (((IList)expando.Value).Count == 0)`
`48`		`- value = typeof(List<object>);`
`49`		`- else`
`50`		`- {`
`51`		`- var internalType = CreateAbstractClassType(((IList)expando.Value)[0]);`
`52`		`- value = new List<object>().Cast(internalType).ToList(internalType).GetType();`
`53`		`- }`
`54`		`-`
	`55`	`+ value = typeof(List<object>);`
`55`	`56`	`}`
`56`	`57`	`else`
`57`	`58`	`{`
`58`		`- value = CreateAbstractClassType(expando.Value);`
	`59`	`+ var internalType = CreateAbstractClassType(list[0]);`
	`60`	`+ value = new List<object>().Cast(internalType).ToList(internalType).GetType();`
`59`	`61`	`}`
`60`		`- props.Add(new DynamicProperty(expando.Key, value));`
	`62`	`+`
	`63`	`+ }`
	`64`	`+ else`
	`65`	`+ {`
	`66`	`+ value = CreateAbstractClassType(expando.Value);`
`61`	`67`	`}`
	`68`	`+ props.Add(new DynamicProperty(expando.Key, value));`
`62`	`69`	`}`
`63`	`70`
`64`	`71`	`var type = DynamicClassFactory.CreateType(props);`
`@@ -67,15 +74,15 @@ public static Type CreateAbstractClassType(dynamic input)`
`67`	`74`
`68`	`75`	`public static object CreateObject(Type type, dynamic input)`
`69`	`76`	`{`
`70`		`- if (!(input is ExpandoObject))`
	`77`	`+ if (input is not ExpandoObject expandoObject)`
`71`	`78`	`{`
`72`	`79`	`return Convert.ChangeType(input, type);`
`73`	`80`	`}`
`74`		`- object obj = Activator.CreateInstance(type);`
	`81`	`+ var obj = Activator.CreateInstance(type);`
`75`	`82`
`76`	`83`	`var typeProps = type.GetProperties().ToDictionary(c => c.Name);`
`77`	`84`
`78`		`- foreach (var expando in (IDictionary<string, object>)input)`
	`85`	`+ foreach (var expando in expandoObject)`
`79`	`86`	`{`
`80`	`87`	`if (typeProps.ContainsKey(expando.Key) &&`
`81`	`88`	`expando.Value != null && (expando.Value.GetType().Name != "DBNull" \|\| expando.Value != DBNull.Value))`
`@@ -87,14 +94,13 @@ public static object CreateObject(Type type, dynamic input)`
`87`	`94`	`var propType = propInfo.PropertyType;`
`88`	`95`	`val = CreateObject(propType, expando.Value);`
`89`	`96`	`}`
`90`		`- else if (expando.Value is IList)`
	`97`	`+ else if (expando.Value is IList temp)`
`91`	`98`	`{`
`92`	`99`	`var internalType = propInfo.PropertyType.GenericTypeArguments.FirstOrDefault() ?? typeof(object);`
`93`		`- var temp = (IList)expando.Value;`
`94`	`100`	`var newList = new List<object>().Cast(internalType).ToList(internalType);`
`95`		`- for (int i = 0; i < temp.Count; i++)`
	`101`	`+ foreach (var t in temp)`
`96`	`102`	`{`
`97`		`- var child = CreateObject(internalType, temp[i]);`
	`103`	`+ var child = CreateObject(internalType, t);`
`98`	`104`	`newList.Add(child);`
`99`	`105`	`};`
`100`	`106`	`val = newList;`