common upgrade according to .NET 9:

Quadarax.Foundation.Core v.0.0.6.0
Quadarax.Foundation.Core.Bussines v.0.0.4.0
Quadarax.Foundation.Core.Data v.0.0.3.0
Quadarax.Foundation.Core.Data.Interface v.0.0.3.0
Quadarax.Foundation.Core.NLog v.0.0.4.0
Quadarax.Foundation.Core.QConsole v.0.0.5.0

qdr.fnd.core.avalonia/qdr.fnd.core.avalonia.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
 	<SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>..\bo_strong_key_pair.snk</AssemblyOriginatorKeyFile>

qdr.fnd.core.business/qdr.fnd.core.business.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>..\bo_strong_key_pair.snk</AssemblyOriginatorKeyFile>
     <DelaySign>false</DelaySign>
@@ -12,17 +12,18 @@
     <Company>Quadarax</Company>
     <Product>Quadarax.Foundation</Product>
     <Description>Quadarax.Foundation.Core.Bussines - bussines layer foundation library</Description>
-    <Copyright>Copyright © 2023,2024 Quadarax</Copyright>
+    <Copyright>Copyright © 2023, 2024, 2025 Quadarax</Copyright>
     <PackageIcon>quadarax_dll.png</PackageIcon>
     <PackageTags>QDR;FND;CORE;BUSSINES</PackageTags>
-    <AssemblyVersion>0.0.3.0</AssemblyVersion>
-    <FileVersion>0.0.3.0</FileVersion>
-    <Version>0.0.3.0-alpha</Version>
+    <AssemblyVersion>0.0.4.0</AssemblyVersion>
+    <FileVersion>0.0.4.0</FileVersion>
+    <Version>0.0.4.0-alpha</Version>
     <Nullable>enable</Nullable>
     <PackageReadmeFile>releasenotes.md</PackageReadmeFile>
     <PackageReleaseNotes>
-      Date:24.3.2024
-      - update dependencies packages (qdr.fnd.core)
+      Date:7.1.2025
+		- update dependency to qdr.fnd.core v.0.0.6.0
+		- update to .NET 9.0
     </PackageReleaseNotes>
   </PropertyGroup>
 
@@ -40,10 +41,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="NLog" Version="5.2.8" />
-    <PackageReference Include="qdr.fnd.core" Version="0.0.4-alpha" />
-    <PackageReference Include="qdr.fnd.core.data" Version="0.0.2-alpha" />
-    <PackageReference Include="qdr.fnd.core.data.itfc" Version="0.0.2-alpha" />
+    <PackageReference Include="NLog" Version="5.3.4" />
+    <PackageReference Include="qdr.fnd.core" Version="0.0.6-alpha" />
+    <PackageReference Include="qdr.fnd.core.data" Version="0.0.3-alpha" />
+    <PackageReference Include="qdr.fnd.core.data.itfc" Version="0.0.3-alpha" />
   </ItemGroup>
 
   <ItemGroup>

qdr.fnd.core.business/releasenotes.md

@@ -1,6 +1,10 @@
 # Quadarax.Foundation.Core * Release notes
 Ordered by version descending
-
+## 0.0.4.0
+Date:__7.1.2025__
+- update dependency to qdr.fnd.core v.0.0.6.0
+- update to .NET 9.0
+---
 ## 0.0.3.0
 Date:__25.3.2024__
 - update packages

qdr.fnd.core.data.itfc/qdr.fnd.core.data.itfc.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>..\bo_strong_key_pair.snk</AssemblyOriginatorKeyFile>
     <DelaySign>false</DelaySign>
@@ -12,17 +12,18 @@
     <Company>Quadarax</Company>
     <Product>Quadarax.Foundation</Product>
     <Description>Quadarax.Foundation.Core.Data.Interfaces - data interface layer foundation library</Description>
-    <Copyright>Copyright © 2023, 2024 Quadarax</Copyright>
+    <Copyright>Copyright © 2023, 2024. 2025 Quadarax</Copyright>
     <PackageIcon>quadarax_dll.png</PackageIcon>
     <PackageTags>QDR;FND;CORE;DATA;INTERFACE</PackageTags>
-    <AssemblyVersion>0.0.2.0</AssemblyVersion>
-    <FileVersion>0.0.2.0</FileVersion>
-    <Version>0.0.2.0-alpha</Version>
+    <AssemblyVersion>0.0.3.0</AssemblyVersion>
+    <FileVersion>0.0.3.0</FileVersion>
+    <Version>0.0.3.0-alpha</Version>
     <Nullable>enable</Nullable>
     <PackageReadmeFile>releasenotes.md</PackageReadmeFile>
     <PackageReleaseNotes>
-      Date:24.3.2024
-      - update dependencies packages (qdr.fnd.core)
+      Date:7.1.2025
+		- update dependency to qdr.fnd.core v.0.0.6.0
+		- update to .NET 9.0
     </PackageReleaseNotes>
   </PropertyGroup>
 
@@ -40,7 +41,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="qdr.fnd.core" Version="0.0.4-alpha" />
+    <PackageReference Include="qdr.fnd.core" Version="0.0.6-alpha" />
   </ItemGroup>
 
   <ItemGroup>

qdr.fnd.core.data.itfc/qdr.fnd.core.data.itfc.csproj.Backup.tmp

@@ -0,0 +1,53 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>..\bo_strong_key_pair.snk</AssemblyOriginatorKeyFile>
+    <DelaySign>false</DelaySign>
+    <RootNamespace>Quadarax.Foundation.Core.Data.Interface</RootNamespace>
+    <ApplicationIcon>..\quadarax_dll.ico</ApplicationIcon>
+    <Title>Quadarax.Foundation.Core.Data.Interface</Title>
+    <Authors>Dalibor Votruba</Authors>
+    <Company>Quadarax</Company>
+    <Product>Quadarax.Foundation</Product>
+    <Description>Quadarax.Foundation.Core.Data.Interfaces - data interface layer foundation library</Description>
+    <Copyright>Copyright © 2023, 2024 Quadarax</Copyright>
+    <PackageIcon>quadarax_dll.png</PackageIcon>
+    <PackageTags>QDR;FND;CORE;DATA;INTERFACE</PackageTags>
+    <AssemblyVersion>0.0.2.0</AssemblyVersion>
+    <FileVersion>0.0.2.0</FileVersion>
+    <Version>0.0.2.0-alpha</Version>
+    <Nullable>enable</Nullable>
+    <PackageReadmeFile>releasenotes.md</PackageReadmeFile>
+    <PackageReleaseNotes>
+      Date:24.3.2024
+      - update dependencies packages (qdr.fnd.core)
+    </PackageReleaseNotes>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Content Include="releasenotes.md">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="..\quadarax_dll.png">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="qdr.fnd.core" Version="0.0.6-alpha" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="releasenotes.md">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
+</Project>

qdr.fnd.core.data.itfc/releasenotes.md

@@ -1,7 +1,11 @@
 # Quadarax.Foundation.Core.Data.Itfc * Release notes
 Ordered by version descending
 
-
+## 0.0.3.0
+Date:__7.1.2025__
+- update dependency to qdr.fnd.core v.0.0.6.0
+- update to .NET 9.0
+---
 ## 0.0.2.0
 Date:__24.3.2024__
 - update dependency to qdr.fnd.core v.0.0.4.0

qdr.fnd.core.data/Extensions/SqlConnectionExt.cs

@@ -6,6 +6,7 @@ namespace Quadarax.Foundation.Core.Data.Extensions
 {
     public static class SqlConnectionExt
     {
+       
         public static SqlDataReader Query(this SqlConnection owner, string query, params SqlParameter[] parameters)
         {
             if (owner == null)

qdr.fnd.core.data/qdr.fnd.core.data.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>..\bo_strong_key_pair.snk</AssemblyOriginatorKeyFile>
     <DelaySign>false</DelaySign>
@@ -12,17 +12,18 @@
     <Company>Quadarax</Company>
     <Product>Quadarax.Foundation</Product>
     <Description>Quadarax.Foundation.Core.Data - data layer foundation library</Description>
-    <Copyright>Copyright © 2023 Quadarax</Copyright>
+    <Copyright>Copyright © 2023. 2024, 2025 Quadarax</Copyright>
     <PackageIcon>quadarax_dll.png</PackageIcon>
     <PackageTags>QDR;FND;CORE;DATA;DAO</PackageTags>
-    <AssemblyVersion>0.0.2.0</AssemblyVersion>
-    <FileVersion>0.0.2.0</FileVersion>
-    <Version>0.0.2.0-alpha</Version>
+    <AssemblyVersion>0.0.3.0</AssemblyVersion>
+    <FileVersion>0.0.3.0</FileVersion>
+    <Version>0.0.3.0-alpha</Version>
     <Nullable>enable</Nullable>
     <PackageReadmeFile>releasenotes.md</PackageReadmeFile>
     <PackageReleaseNotes>
-      Date:24.3.2024
-      - update dependencies packages (qdr.fnd.core)
+      Date:7.1.2025
+		- update dependency to qdr.fnd.core v.0.0.6.0
+		- update to .NET 9.0
     </PackageReleaseNotes>
   </PropertyGroup>
 
@@ -47,10 +48,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.17" />
-    <PackageReference Include="qdr.fnd.core" Version="0.0.4-alpha" />
-    <PackageReference Include="qdr.fnd.core.data.itfc" Version="0.0.2-alpha" />
-    <PackageReference Include="System.Data.SqlClient" Version="4.8.6" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.0" />
+    <PackageReference Include="qdr.fnd.core" Version="0.0.6-alpha" />
+    <PackageReference Include="qdr.fnd.core.data.itfc" Version="0.0.3-alpha" />
+    <PackageReference Include="System.Data.SqlClient" Version="4.9.0" />
   </ItemGroup>
 
   <ItemGroup>

qdr.fnd.core.data/releasenotes.md

@@ -1,7 +1,11 @@
 # Quadarax.Foundation.Core.Data * Release notes
 Ordered by version descending
 
-
+## 0.0.3.0
+Date:__7.1.2025__
+- update dependency to qdr.fnd.core v.0.0.6.0
+- update to .NET 9.0
+---
 ## 0.0.2.0
 Date:__24.3.2024__
 - update dependency to qdr.fnd.core v.0.0.4.0

qdr.fnd.core.nlog/qdr.fnd.core.nlog.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>..\bo_strong_key_pair.snk</AssemblyOriginatorKeyFile>
     <DelaySign>false</DelaySign>
@@ -12,17 +12,18 @@
     <Company>Quadarax</Company>
     <Product>Quadarax.Foundation</Product>
     <Description>Quadarax.Foundation.Core.NLog - logging provider for NLog under logging infrastructure in foundation library</Description>
-    <Copyright>Copyright © 2023,2024 Quadarax</Copyright>
+    <Copyright>Copyright © 2023,2024,2025 Quadarax</Copyright>
     <PackageIcon>quadarax_dll.png</PackageIcon>
     <PackageTags>QDR;FND;CORE;NLOG</PackageTags>
-    <AssemblyVersion>0.0.3.0</AssemblyVersion>
-    <FileVersion>0.0.3.0</FileVersion>
-    <Version>0.0.3.0-alpha</Version>
+    <AssemblyVersion>0.0.4.0</AssemblyVersion>
+    <FileVersion>0.0.4.0</FileVersion>
+    <Version>0.0.4.0-alpha</Version>
     <Nullable>enable</Nullable>
     <PackageReadmeFile>releasenotes.md</PackageReadmeFile>
     <PackageReleaseNotes>
-      Date:24.3.2024
-      - update dependencies packages (qdr.fnd.core)
+      Date:7.1.2025
+		- update dependency to qdr.fnd.core v.0.0.6.0
+		- update to .NET 9.0
     </PackageReleaseNotes>
   </PropertyGroup>
 
@@ -40,9 +41,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="NLog" Version="5.2.8" />
-    <PackageReference Include="NLog.Extensions.Logging" Version="5.3.8" />
-    <PackageReference Include="qdr.fnd.core" Version="0.0.4-alpha" />
+    <PackageReference Include="NLog" Version="5.3.4" />
+    <PackageReference Include="NLog.Extensions.Logging" Version="5.3.15" />
+    <PackageReference Include="qdr.fnd.core" Version="0.0.6-alpha" />
   </ItemGroup>
 
   <ItemGroup>

qdr.fnd.core.nlog/qdr.fnd.core.nlog.csproj.Backup.tmp

@@ -0,0 +1,55 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>..\bo_strong_key_pair.snk</AssemblyOriginatorKeyFile>
+    <DelaySign>false</DelaySign>
+    <RootNamespace>Quadarax.Foundation.Core.NLog</RootNamespace>
+    <ApplicationIcon>..\quadarax_dll.ico</ApplicationIcon>
+    <Title>Quadarax.Foundation.Core.NLog</Title>
+    <Authors>Dalibor Votruba</Authors>
+    <Company>Quadarax</Company>
+    <Product>Quadarax.Foundation</Product>
+    <Description>Quadarax.Foundation.Core.NLog - logging provider for NLog under logging infrastructure in foundation library</Description>
+    <Copyright>Copyright © 2023,2024 Quadarax</Copyright>
+    <PackageIcon>quadarax_dll.png</PackageIcon>
+    <PackageTags>QDR;FND;CORE;NLOG</PackageTags>
+    <AssemblyVersion>0.0.3.0</AssemblyVersion>
+    <FileVersion>0.0.3.0</FileVersion>
+    <Version>0.0.3.0-alpha</Version>
+    <Nullable>enable</Nullable>
+    <PackageReadmeFile>releasenotes.md</PackageReadmeFile>
+    <PackageReleaseNotes>
+      Date:24.3.2024
+      - update dependencies packages (qdr.fnd.core)
+    </PackageReleaseNotes>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Content Include="releasenotes.md">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="..\quadarax_dll.png">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="NLog" Version="5.3.4" />
+    <PackageReference Include="NLog.Extensions.Logging" Version="5.3.15" />
+    <PackageReference Include="qdr.fnd.core" Version="0.0.6-alpha" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="releasenotes.md">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
+</Project>

qdr.fnd.core.nlog/releasenotes.md

@@ -1,7 +1,11 @@
 # Quadarax.Foundation.Core.NLog * Release notes
 Ordered by version descending
 
-
+## 0.0.4.0
+Date:__7.1.2025__
+- update dependency to qdr.fnd.core v.0.0.6.0
+- update to .NET 9.0
+---
 ## 0.0.2.0
 Date:__24.3.2024__
 - update dependency to qdr.fnd.core v.0.0.4.0

qdr.fnd.core.pqueue.test/Mocks/PsQueueItemMock.cs

@@ -34,7 +34,13 @@ namespace qdr.fnd.core.pqueue.test.Mocks
                 
                 storage.CreateItemAttribute(itemId, argument.Name, argument.Value, argument.ValueType.FullName, argument.IsOutput);
             }
+            storage.UpdateItemStatus(itemId, Status,IsStatusTransient);
             Id = itemId;
         }
+        public void SetValidity(DateTime validFrom, DateTime? validTo)
+        {
+            ValidFrom = validFrom;
+            ValidTo = validTo;
+        }
     }
 }

qdr.fnd.core.pqueue.test/Mocks/PsQueueMock.cs

@@ -47,7 +47,7 @@ namespace qdr.fnd.core.pqueue.test.Mocks
         }
         public void TestEnsureItemStateExpired(IPsQueueItem item)
         {
-            TestEnsureItemStateExpired(item);
+            EnsureItemStateExpired(item);
         }
         public IPsQueueItem TestGetItemInternal(string itemId)
         {

qdr.fnd.core.pqueue.test/PsQueueTest.cs

@@ -206,6 +206,24 @@ namespace qdr.fnd.core.pqueue.test
 
         }
 
+        [Test(TestOf=typeof(PsQueue))]
+        public void EnsureItemStateExpiredOk()
+        {
+            var queue = CreateQueue();
+            var item = CreateQueueItem(_id);
+            
+            // no expiration
+            item.SetValidity(DateTime.Now.AddSeconds(-10), DateTime.Now.AddSeconds(100));
+            item.SetStatus(PsStatusEnum.Pending, false, "noway");
+            item.AddToStorage(queue.Storage);
+
+            queue.TestEnsureItemStateExpired(item);
+            var changedItem = queue.Storage.GetItem(item.Id);
+            Assert.That(changedItem.Status, Is.EqualTo(PsStatusEnum.Pending));
+            Assert.That(changedItem.IsStatusTransient, Is.EqualTo(false));
+            
+        }
+
         private PsQueueMock CreateQueue()
         {
             var ps = new PsQueueMock(_queueName, _configuration!, _storageProvider!, _logger!);

qdr.fnd.core.pqueue/PsQueueItem.cs

@@ -20,10 +20,10 @@ namespace qdr.fnd.core.pqueue
         public int Priority { get; internal set; }
 
         /// <inheritdoc />
-        public DateTime ValidFrom { get; internal set; }
+        public DateTime ValidFrom { get; protected internal set; }
 
         /// <inheritdoc />
-        public DateTime? ValidTo { get; internal set; }
+        public DateTime? ValidTo { get; protected internal set; }
 
         /// <inheritdoc />
         public DateTime Created { get; protected set; }

qdr.fnd.core.qconsole/qdr.fnd.core.qconsole.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>..\bo_strong_key_pair.snk</AssemblyOriginatorKeyFile>
     <DelaySign>false</DelaySign>
@@ -12,17 +12,18 @@
     <Company>Quadarax</Company>
     <Product>Quadarax.Foundation</Product>
     <Description>Quadarax.Foundation.Core.QConsole - abstract console engine under foundation library</Description>
-    <Copyright>Copyright © 2023,2024 Quadarax</Copyright>
+    <Copyright>Copyright © 2023,2024,2025 Quadarax</Copyright>
     <PackageIcon>quadarax_dll.png</PackageIcon>
     <PackageTags>QDR;FND;CORE;CONSOLE</PackageTags>
-    <AssemblyVersion>0.0.4.0</AssemblyVersion>
-    <FileVersion>0.0.4.0</FileVersion>
-    <Version>0.0.4.0-alpha</Version>
+    <AssemblyVersion>0.0.5.0</AssemblyVersion>
+    <FileVersion>0.0.5.0</FileVersion>
+    <Version>0.0.5.0-alpha</Version>
     <Nullable>enable</Nullable>
     <PackageReadmeFile>releasenotes.md</PackageReadmeFile>
     <PackageReleaseNotes>
-      Date:24.3.2024
-      - update dependencies packages (qdr.fnd.core)
+      Date:7.1.2025
+      - update dependency to qdr.fnd.core v.0.0.6.0
+		- update to .NET 9.0
     </PackageReleaseNotes>
   </PropertyGroup>
 
@@ -41,7 +42,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="qdr.fnd.core" Version="0.0.4-alpha" />
+    <PackageReference Include="qdr.fnd.core" Version="0.0.6-alpha" />
   </ItemGroup>
 
   <ItemGroup>

qdr.fnd.core.qconsole/releasenotes.md

@@ -1,6 +1,11 @@
 # Quadarax.Foundation.Core.QConsole * Release notes
 Ordered by version descending
 
+## 0.0.5.0
+Date:__7.1.2025__
+- update dependency to qdr.fnd.core v.0.0.6.0
+- update to .NET 9.0
+---
 ## 0.0.4.0
 Date:__24.3.2024__
 - update dependencies packages (qdr.fnd.core)

qdr.fnd.core.test/IO/FileSearchTest.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace qdr.fnd.core.test.IO
+{
+    internal class FileSearchTest
+    {
+
+    }
+}

qdr.fnd.core.test/qdr.fnd.core.test.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
 

qdr.fnd.core.web/qdr.fnd.core.web.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>..\bo_strong_key_pair.snk</AssemblyOriginatorKeyFile>
     <DelaySign>false</DelaySign>
@@ -29,10 +29,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Core" Version="2.2.5" />
-    <PackageReference Include="NLog" Version="5.2.8" />
-    <PackageReference Include="qdr.fnd.core" Version="0.0.1-alpha" />
-    <PackageReference Include="qdr.fnd.core.business" Version="0.0.1-alpha" />
+    <PackageReference Include="NLog" Version="5.3.4" />
+    <PackageReference Include="qdr.fnd.core" Version="0.0.6-alpha" />
+    <PackageReference Include="qdr.fnd.core.business" Version="0.0.4-alpha" />
   </ItemGroup>
 
 </Project>

qdr.fnd.core/IO/FileSearch.cs

@@ -33,7 +33,7 @@ namespace Quadarax.Foundation.Core.IO
 
         }
 
-        public FileSearch(string initialPath, bool includeSubdirs = true) : this(new FileSystem(),initialPath, includeSubdirs)
+        public FileSearch(string initialPath, bool includeSubdirs = true) : this(new System.IO.Abstractions.FileSystem(),initialPath, includeSubdirs)
         {
         }
         #endregion

qdr.fnd.core/IO/FileSystem/Memory/MemoryDirectory.cs

@@ -0,0 +1,739 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Abstractions;
+using System.Linq;
+using System.Text.RegularExpressions;
+namespace Quadarax.Foundation.Core.IO.FileSystem.Memory
+{
+
+
+    public class MemoryDirectory : IDirectory
+    {
+        private readonly MemoryFileSystem _fileSystem;
+
+        public IFileSystem FileSystem => _fileSystem;
+
+        public MemoryDirectory(MemoryFileSystem fileSystem)
+        {
+            _fileSystem = fileSystem;
+        }
+
+        public IDirectoryInfo CreateDirectory(string path)
+        {
+            if (string.IsNullOrWhiteSpace(path))
+            {
+                throw new ArgumentException("Path cannot be null or whitespace.", nameof(path));
+            }
+
+            // Normalize the path
+            string normalizedPath = _fileSystem.Path.GetFullPath(path);
+
+            // Split the path into its components
+            string[] pathParts = normalizedPath.Split(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries);
+
+            string? currentPath = _fileSystem.Path.GetPathRoot(normalizedPath);
+            MemoryDirectoryEntry? currentDir = null;
+
+            // Ensure the root directory exists
+            if (!_fileSystem.FileSystemDictionary.TryGetValue(currentPath ?? string.Empty, out var rootEntry))
+            {
+                rootEntry = new MemoryDirectoryEntry
+                {
+                    Name = currentPath ?? string.Empty,
+                    FullName = currentPath ?? string.Empty,
+                    Attributes = FileAttributes.Directory,
+                    CreationTime = DateTime.Now,
+                    LastAccessTime = DateTime.Now,
+                    LastWriteTime = DateTime.Now
+                };
+                _fileSystem.FileSystemDictionary[currentPath ?? string.Empty] = rootEntry;
+            }
+            currentDir = (MemoryDirectoryEntry)rootEntry;
+
+            // Create or navigate through each directory in the path
+            foreach (string part in pathParts.Skip(1)) // Skip the root
+            {
+                currentPath = Path.Combine(currentPath ?? string.Empty, part);
+
+                if (_fileSystem.FileSystemDictionary.TryGetValue(currentPath, out var existingEntry))
+                {
+                    if (existingEntry is MemoryFileEntry)
+                    {
+                        throw new IOException($"Cannot create directory '{currentPath}': A file with the same name already exists.");
+                    }
+                    currentDir = (MemoryDirectoryEntry)existingEntry;
+                }
+                else
+                {
+                    var newDir = new MemoryDirectoryEntry
+                    {
+                        Name = part,
+                        FullName = currentPath,
+                        Attributes = FileAttributes.Directory,
+                        CreationTime = DateTime.Now,
+                        LastAccessTime = DateTime.Now,
+                        LastWriteTime = DateTime.Now
+                    };
+                    _fileSystem.FileSystemDictionary[currentPath] = newDir;
+                    currentDir.Children[part] = newDir;
+                    currentDir = newDir;
+                }
+            }
+
+            // Update the last access time of the final directory
+            currentDir.LastAccessTime = DateTime.Now;
+
+            // Return an IDirectoryInfo object for the created or existing directory
+            return new MemoryDirectoryInfo(_fileSystem, normalizedPath);
+        }
+
+        public void Delete(string path)
+        {
+            Delete(path, false);
+        }
+
+        public void Delete(string path, bool recursive)
+        {
+            var normalizedPath = NormalizePath(path);
+            if (!_fileSystem.FileSystemDictionary.TryGetValue(normalizedPath, out var entry) || !(entry is MemoryDirectoryEntry dirEntry))
+            {
+                throw new DirectoryNotFoundException($"Directory not found: {normalizedPath}");
+            }
+
+            if (!recursive && dirEntry.Children.Count > 0)
+            {
+                throw new IOException($"The directory '{normalizedPath}' is not empty.");
+            }
+
+            var keysToRemove = _fileSystem.FileSystemDictionary.Keys
+                .Where(k => k.StartsWith(normalizedPath))
+                .ToList();
+
+            foreach (var key in keysToRemove)
+            {
+                _fileSystem.FileSystemDictionary.Remove(key);
+            }
+        }
+
+        public IEnumerable<string> EnumerateDirectories(string path)
+        {
+            return EnumerateDirectories(path, "*", SearchOption.TopDirectoryOnly);
+        }
+
+        public IEnumerable<string> EnumerateDirectories(string path, string searchPattern)
+        {
+            return EnumerateDirectories(path, searchPattern, SearchOption.TopDirectoryOnly);
+        }
+
+        public IEnumerable<string> EnumerateDirectories(string path, string searchPattern, SearchOption searchOption)
+        {
+            var normalizedPath = NormalizePath(path);
+            if (!_fileSystem.FileSystemDictionary.TryGetValue(normalizedPath, out var entry) || !(entry is MemoryDirectoryEntry dirEntry))
+            {
+                throw new DirectoryNotFoundException($"Directory not found: {normalizedPath}");
+            }
+
+            var directories = new List<string>();
+            EnumerateDirectoriesRecursive(dirEntry, searchPattern, searchOption, directories);
+            return directories;
+        }
+
+        private void EnumerateDirectoriesRecursive(MemoryDirectoryEntry directory, string searchPattern, SearchOption searchOption, List<string> result)
+        {
+            foreach (var child in directory.Children.Values)
+            {
+                if (child is MemoryDirectoryEntry childDir && MatchesPattern(child.Name, searchPattern))
+                {
+                    result.Add(child.FullName);
+                    if (searchOption == SearchOption.AllDirectories)
+                    {
+                        EnumerateDirectoriesRecursive(childDir, searchPattern, searchOption, result);
+                    }
+                }
+            }
+        }
+
+        public IEnumerable<string> EnumerateFiles(string path)
+        {
+            return EnumerateFiles(path, "*", SearchOption.TopDirectoryOnly);
+        }
+
+        public IEnumerable<string> EnumerateFiles(string path, string searchPattern)
+        {
+            return EnumerateFiles(path, searchPattern, SearchOption.TopDirectoryOnly);
+        }
+
+        public IEnumerable<string> EnumerateFiles(string path, string searchPattern, SearchOption searchOption)
+        {
+            var normalizedPath = NormalizePath(path);
+            if (!_fileSystem.FileSystemDictionary.TryGetValue(normalizedPath, out var entry) || !(entry is MemoryDirectoryEntry dirEntry))
+            {
+                throw new DirectoryNotFoundException($"Directory not found: {normalizedPath}");
+            }
+
+            var files = new List<string>();
+            EnumerateFilesRecursive(dirEntry, searchPattern, searchOption, files);
+            return files;
+        }
+
+        private void EnumerateFilesRecursive(MemoryDirectoryEntry directory, string searchPattern, SearchOption searchOption, List<string> result)
+        {
+            foreach (var child in directory.Children.Values)
+            {
+                if (child is MemoryFileEntry && MatchesPattern(child.Name, searchPattern))
+                {
+                    result.Add(child.FullName);
+                }
+                else if (child is MemoryDirectoryEntry childDir && searchOption == SearchOption.AllDirectories)
+                {
+                    EnumerateFilesRecursive(childDir, searchPattern, searchOption, result);
+                }
+            }
+        }
+
+        public IEnumerable<string> EnumerateFileSystemEntries(string path)
+        {
+            return EnumerateFileSystemEntries(path, "*", SearchOption.TopDirectoryOnly);
+        }
+
+        public IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern)
+        {
+            return EnumerateFileSystemEntries(path, searchPattern, SearchOption.TopDirectoryOnly);
+        }
+
+        public IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern, SearchOption searchOption)
+        {
+            var normalizedPath = NormalizePath(path);
+            if (!_fileSystem.FileSystemDictionary.TryGetValue(normalizedPath, out var entry) || !(entry is MemoryDirectoryEntry dirEntry))
+            {
+                throw new DirectoryNotFoundException($"Directory not found: {normalizedPath}");
+            }
+
+            var entries = new List<string>();
+            EnumerateFileSystemEntriesRecursive(dirEntry, searchPattern, searchOption, entries);
+            return entries;
+        }
+
+        private void EnumerateFileSystemEntriesRecursive(MemoryDirectoryEntry directory, string searchPattern, SearchOption searchOption, List<string> result)
+        {
+            foreach (var child in directory.Children.Values)
+            {
+                if (MatchesPattern(child.Name, searchPattern))
+                {
+                    result.Add(child.FullName);
+                }
+
+                if (child is MemoryDirectoryEntry childDir && searchOption == SearchOption.AllDirectories)
+                {
+                    EnumerateFileSystemEntriesRecursive(childDir, searchPattern, searchOption, result);
+                }
+            }
+        }
+
+        public bool Exists(string? path)
+        {
+            var normalizedPath = NormalizePath(path);
+            return _fileSystem.FileSystemDictionary.TryGetValue(normalizedPath, out var entry) && entry is MemoryDirectoryEntry;
+        }
+
+        public string[] GetDirectories(string path)
+        {
+            return GetDirectories(path, "*", SearchOption.TopDirectoryOnly);
+        }
+
+        public string[] GetDirectories(string path, string searchPattern)
+        {
+            return GetDirectories(path, searchPattern, SearchOption.TopDirectoryOnly);
+        }
+
+        public string[] GetDirectories(string path, string searchPattern, SearchOption searchOption)
+        {
+            return EnumerateDirectories(path, searchPattern, searchOption).ToArray();
+        }
+
+        public string[] GetFiles(string path)
+        {
+            return GetFiles(path, "*", SearchOption.TopDirectoryOnly);
+        }
+
+        public string[] GetFiles(string path, string searchPattern)
+        {
+            return GetFiles(path, searchPattern, SearchOption.TopDirectoryOnly);
+        }
+
+        public string[] GetFiles(string path, string searchPattern, SearchOption searchOption)
+        {
+            return EnumerateFiles(path, searchPattern, searchOption).ToArray();
+        }
+
+        public string[] GetFileSystemEntries(string path)
+        {
+            return GetFileSystemEntries(path, "*", SearchOption.TopDirectoryOnly);
+        }
+
+        public string[] GetFileSystemEntries(string path, string searchPattern)
+        {
+            return GetFileSystemEntries(path, searchPattern, SearchOption.TopDirectoryOnly);
+        }
+
+        public string[] GetFileSystemEntries(string path, string searchPattern, SearchOption searchOption)
+        {
+            return EnumerateFileSystemEntries(path, searchPattern, searchOption).ToArray();
+        }
+
+        public void Move(string sourceDirName, string destDirName)
+        {
+            var normalizedSourcePath = NormalizePath(sourceDirName);
+            var normalizedDestPath = NormalizePath(destDirName);
+
+            if (!_fileSystem.FileSystemDictionary.TryGetValue(normalizedSourcePath, out var sourceEntry) || !(sourceEntry is MemoryDirectoryEntry sourceDir))
+            {
+                throw new DirectoryNotFoundException($"Source directory not found: {normalizedSourcePath}");
+            }
+
+            if (_fileSystem.FileSystemDictionary.ContainsKey(normalizedDestPath))
+            {
+                throw new IOException($"Cannot create '{normalizedDestPath}' because a file or directory with the same name already exists.");
+            }
+
+            var entriesToMove = _fileSystem.FileSystemDictionary
+                .Where(kvp => kvp.Key.StartsWith(normalizedSourcePath))
+                .ToList();
+
+            foreach (var entry in entriesToMove)
+            {
+                var newPath = entry.Key.Replace(normalizedSourcePath, normalizedDestPath);
+                _fileSystem.FileSystemDictionary[newPath] = entry.Value;
+                entry.Value.FullName = newPath;
+                _fileSystem.FileSystemDictionary.Remove(entry.Key);
+            }
+        }
+
+        private string NormalizePath(string? path)
+        {
+            if (path == null)
+                return string.Empty;
+            return Path.GetFullPath(path).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+        }
+
+        private bool MatchesPattern(string name, string pattern)
+        {
+            return System.Text.RegularExpressions.Regex.IsMatch(name, "^" + System.Text.RegularExpressions.Regex.Escape(pattern).Replace("\\*", ".*").Replace("\\?", ".") + "$");
+        }
+
+        public IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern, EnumerationOptions enumerationOptions)
+        {
+            var normalizedPath = NormalizePath(path);
+            if (!_fileSystem.FileSystemDictionary.TryGetValue(normalizedPath, out var entry) || !(entry is MemoryDirectoryEntry dirEntry))
+            {
+                throw new DirectoryNotFoundException($"Directory not found: {normalizedPath}");
+            }
+
+            var entries = new List<string>();
+            EnumerateFileSystemEntriesRecursive(dirEntry, searchPattern, enumerationOptions, entries);
+            return entries;
+        }
+
+        private void EnumerateFileSystemEntriesRecursive(MemoryDirectoryEntry directory, string searchPattern, EnumerationOptions options, List<string> result)
+        {
+            foreach (var child in directory.Children.Values)
+            {
+                if (ShouldIncludeEntry(child, searchPattern, options))
+                {
+                    result.Add(child.FullName);
+                }
+
+                if (child is MemoryDirectoryEntry childDir && options.RecurseSubdirectories)
+                {
+                    EnumerateFileSystemEntriesRecursive(childDir, searchPattern, options, result);
+                }
+            }
+
+            if (options.ReturnSpecialDirectories)
+            {
+                if (MatchesPattern(".", searchPattern, options) && !result.Contains(directory.FullName))
+                {
+                    result.Add(directory.FullName);
+                }
+
+                var parentDir = Path.GetDirectoryName(directory.FullName);
+                if (parentDir != null && MatchesPattern("..", searchPattern, options) && !result.Contains(parentDir))
+                {
+                    result.Add(parentDir);
+                }
+            }
+        }
+
+        private bool ShouldIncludeEntry(MemoryFileSystemEntry entry, string searchPattern, EnumerationOptions options)
+        {
+            if ((entry.Attributes & options.AttributesToSkip) != 0)
+            {
+                return false;
+            }
+
+            if (options.IgnoreInaccessible)
+            {
+                // Simulate inaccessible entries (e.g., by checking a hypothetical 'IsAccessible' property)
+                // For this example, we'll assume all entries are accessible
+            }
+
+            return MatchesPattern(entry.Name, searchPattern, options);
+        }
+        public IEnumerable<string> EnumerateFiles(string path, string searchPattern, EnumerationOptions enumerationOptions)
+        {
+            var normalizedPath = NormalizePath(path);
+            if (!_fileSystem.FileSystemDictionary.TryGetValue(normalizedPath, out var entry) || !(entry is MemoryDirectoryEntry dirEntry))
+            {
+                throw new DirectoryNotFoundException($"Directory not found: {normalizedPath}");
+            }
+
+            var files = new List<string>();
+            EnumerateFilesRecursive(dirEntry, searchPattern, enumerationOptions, files);
+            return files;
+        }
+
+        private void EnumerateFilesRecursive(MemoryDirectoryEntry directory, string searchPattern, EnumerationOptions options, List<string> result)
+        {
+            foreach (var child in directory.Children.Values)
+            {
+                if (child is MemoryFileEntry fileEntry)
+                {
+                    if (ShouldIncludeFile(fileEntry, searchPattern, options))
+                    {
+                        result.Add(child.FullName);
+                    }
+                }
+                else if (child is MemoryDirectoryEntry childDir && options.RecurseSubdirectories)
+                {
+                    EnumerateFilesRecursive(childDir, searchPattern, options, result);
+                }
+            }
+        }
+
+        private bool ShouldIncludeFile(MemoryFileEntry file, string searchPattern, EnumerationOptions options)
+        {
+            if ((file.Attributes & options.AttributesToSkip) != 0)
+            {
+                return false;
+            }
+
+            if (options.IgnoreInaccessible)
+            {
+                // Simulate inaccessible files (e.g., by checking a hypothetical 'IsAccessible' property)
+                // For this example, we'll assume all files are accessible
+            }
+
+            return MatchesPattern(file.Name, searchPattern, options);
+        }
+
+
+
+        private bool MatchesWin32(string name, string pattern, MatchCasing matchCasing)
+        {
+            string regexPattern = "^" + Regex.Escape(pattern)
+                .Replace("\\*", ".*")
+                .Replace("\\?", ".")
+                + "$";
+
+            RegexOptions regexOptions = matchCasing == MatchCasing.CaseInsensitive
+                ? RegexOptions.IgnoreCase
+                : RegexOptions.None;
+
+            return Regex.IsMatch(name, regexPattern, regexOptions);
+        }
+
+        private bool MatchesSimple(string name, string pattern, MatchCasing matchCasing)
+        {
+            return matchCasing == MatchCasing.CaseInsensitive
+                ? name.Equals(pattern, StringComparison.OrdinalIgnoreCase)
+                : name.Equals(pattern, StringComparison.Ordinal);
+        }
+
+        private bool MatchesRegex(string name, string pattern, MatchCasing matchCasing)
+        {
+            RegexOptions regexOptions = matchCasing == MatchCasing.CaseInsensitive
+                ? RegexOptions.IgnoreCase
+                : RegexOptions.None;
+
+            return Regex.IsMatch(name, pattern, regexOptions);
+        }
+        private bool MatchesPattern(string name, string pattern, EnumerationOptions options)
+        {
+            if (options.MatchType == MatchType.Win32)
+            {
+                return MatchesWin32(name, pattern, options.MatchCasing);
+            }
+            else if (options.MatchType == MatchType.Simple)
+            {
+                return MatchesSimple(name, pattern, options.MatchCasing);
+            }
+            else // MatchType.Regular
+            {
+                return MatchesRegex(name, pattern, options.MatchCasing);
+            }
+        }
+
+
+        public IDirectoryInfo CreateDirectory(string path, UnixFileMode unixCreateMode)
+        {
+            if (string.IsNullOrWhiteSpace(path))
+            {
+                throw new ArgumentException("Path cannot be null or whitespace.", nameof(path));
+            }
+
+            // Normalize the path
+            string normalizedPath = _fileSystem.Path.GetFullPath(path);
+
+            // Split the path into its components
+            string[] pathParts = normalizedPath.Split(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries);
+
+            string? currentPath = _fileSystem.Path.GetPathRoot(normalizedPath);
+            MemoryDirectoryEntry? currentDir = null;
+
+            // Ensure the root directory exists
+            if (!_fileSystem.FileSystemDictionary.TryGetValue(currentPath ?? string.Empty, out var rootEntry))
+            {
+                rootEntry = new MemoryDirectoryEntry
+                {
+                    Name = currentPath ?? string.Empty,
+                    FullName = currentPath ?? string.Empty,
+                    Attributes = FileAttributes.Directory,
+                    CreationTime = DateTime.Now,
+                    LastAccessTime = DateTime.Now,
+                    LastWriteTime = DateTime.Now,
+                    UnixFileMode = System.IO.UnixFileMode.None
+                };
+                _fileSystem.FileSystemDictionary[currentPath ?? string.Empty] = rootEntry;
+            }
+            currentDir = (MemoryDirectoryEntry)rootEntry;
+
+            // Create or navigate through each directory in the path
+            foreach (string part in pathParts.Skip(1)) // Skip the root
+            {
+                currentPath = Path.Combine(currentPath ?? string.Empty, part);
+
+                if (_fileSystem.FileSystemDictionary.TryGetValue(currentPath, out var existingEntry))
+                {
+                    if (existingEntry is MemoryFileEntry)
+                    {
+                        throw new IOException($"Cannot create directory '{currentPath}': A file with the same name already exists.");
+                    }
+                    currentDir = (MemoryDirectoryEntry)existingEntry;
+                }
+                else
+                {
+                    var newDir = new MemoryDirectoryEntry
+                    {
+                        Name = part,
+                        FullName = currentPath,
+                        Attributes = FileAttributes.Directory,
+                        CreationTime = DateTime.Now,
+                        LastAccessTime = DateTime.Now,
+                        LastWriteTime = DateTime.Now,
+                        UnixFileMode = unixCreateMode
+                    };
+                    _fileSystem.FileSystemDictionary[currentPath] = newDir;
+                    currentDir.Children[part] = newDir;
+                    currentDir = newDir;
+                }
+            }
+
+            // Update the last access time of the final directory
+            currentDir.LastAccessTime = DateTime.Now;
+
+            // Return an IDirectoryInfo object for the created or existing directory
+            return new MemoryDirectoryInfo(_fileSystem, normalizedPath);
+        }
+
+        public IFileSystemInfo CreateSymbolicLink(string path, string pathToTarget)
+        {
+            if (string.IsNullOrWhiteSpace(path))
+            {
+                throw new ArgumentException("Path cannot be null or whitespace.", nameof(path));
+            }
+
+            if (string.IsNullOrWhiteSpace(pathToTarget))
+            {
+                throw new ArgumentException("Target path cannot be null or whitespace.", nameof(pathToTarget));
+            }
+
+            // Normalize the paths
+            string normalizedPath = _fileSystem.Path.GetFullPath(path);
+            string normalizedTargetPath = _fileSystem.Path.GetFullPath(pathToTarget);
+
+            // Check if the symlink already exists
+            if (_fileSystem.FileSystemDictionary.ContainsKey(normalizedPath))
+            {
+                throw new IOException($"Cannot create '{normalizedPath}': A file or directory with the same name already exists.");
+            }
+
+            // Determine if the target is a file or directory
+            bool isTargetDirectory = _fileSystem.Directory.Exists(normalizedTargetPath);
+
+            // Create the symbolic link entry
+            MemoryFileSystemEntry symlinkEntry;
+            if (isTargetDirectory)
+            {
+                symlinkEntry = new MemoryDirectoryEntry
+                {
+                    Name = _fileSystem.Path.GetFileName(normalizedPath),
+                    FullName = normalizedPath,
+                    Attributes = FileAttributes.Directory | FileAttributes.ReparsePoint,
+                    CreationTime = DateTime.Now,
+                    LastAccessTime = DateTime.Now,
+                    LastWriteTime = DateTime.Now,
+                    IsSymbolicLink = true,
+                    SymbolicLinkTarget = normalizedTargetPath
+                };
+            }
+            else
+            {
+                symlinkEntry = new MemoryFileEntry
+                {
+                    Name = _fileSystem.Path.GetFileName(normalizedPath),
+                    FullName = normalizedPath,
+                    Attributes = FileAttributes.ReparsePoint,
+                    CreationTime = DateTime.Now,
+                    LastAccessTime = DateTime.Now,
+                    LastWriteTime = DateTime.Now,
+                    IsSymbolicLink = true,
+                    SymbolicLinkTarget = normalizedTargetPath
+                };
+            }
+
+            // Add the symlink to the file system
+            _fileSystem.FileSystemDictionary[normalizedPath] = symlinkEntry;
+
+            // Add the symlink to its parent directory's children
+            string? parentPath = _fileSystem.Path.GetDirectoryName(normalizedPath);
+            if (_fileSystem.FileSystemDictionary.TryGetValue(parentPath ?? string.Empty, out var parentEntry) && parentEntry is MemoryDirectoryEntry parentDir)
+            {
+                parentDir.Children[symlinkEntry.Name] = symlinkEntry;
+            }
+
+            // Return the appropriate IFileSystemInfo object
+            return isTargetDirectory
+                ? (IFileSystemInfo)new MemoryDirectoryInfo(_fileSystem, normalizedPath)
+                : new MemoryFileInfo(_fileSystem, normalizedPath);
+        }
+
+        public IDirectoryInfo CreateTempSubdirectory(string? prefix = null)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerable<string> EnumerateDirectories(string path, string searchPattern, EnumerationOptions enumerationOptions)
+        {
+            throw new NotImplementedException();
+        }
+
+
+        public DateTime GetCreationTime(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetCreationTimeUtc(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string GetCurrentDirectory()
+        {
+            throw new NotImplementedException();
+        }
+
+        public string[] GetDirectories(string path, string searchPattern, EnumerationOptions enumerationOptions)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string GetDirectoryRoot(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string[] GetFiles(string path, string searchPattern, EnumerationOptions enumerationOptions)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string[] GetFileSystemEntries(string path, string searchPattern, EnumerationOptions enumerationOptions)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetLastAccessTime(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetLastAccessTimeUtc(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetLastWriteTime(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetLastWriteTimeUtc(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string[] GetLogicalDrives()
+        {
+            throw new NotImplementedException();
+        }
+
+        public IDirectoryInfo? GetParent(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IFileSystemInfo? ResolveLinkTarget(string linkPath, bool returnFinalTarget)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetCreationTime(string path, DateTime creationTime)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetCreationTimeUtc(string path, DateTime creationTimeUtc)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetCurrentDirectory(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetLastAccessTime(string path, DateTime lastAccessTime)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetLastAccessTimeUtc(string path, DateTime lastAccessTimeUtc)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetLastWriteTime(string path, DateTime lastWriteTime)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetLastWriteTimeUtc(string path, DateTime lastWriteTimeUtc)
+        {
+            throw new NotImplementedException();
+        }
+
+        // Implement other methods (e.g., GetParent, GetDirectoryRoot) as needed
+    }
+}

qdr.fnd.core/IO/FileSystem/Memory/MemoryDirectoryEntry .cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+
+namespace Quadarax.Foundation.Core.IO.FileSystem.Memory
+{
+    internal class MemoryDirectoryEntry : MemoryFileSystemEntry
+    {
+        public Dictionary<string, MemoryFileSystemEntry> Children { get; }
+        public MemoryDirectoryEntry()
+        {
+            Children = new Dictionary<string, MemoryFileSystemEntry>(StringComparer.OrdinalIgnoreCase);
+            UnixFileMode = System.IO.UnixFileMode.None;
+        }
+    }
+}

qdr.fnd.core/IO/FileSystem/Memory/MemoryDirectoryInfo.cs

@@ -0,0 +1,418 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Abstractions;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Quadarax.Foundation.Core.IO.FileSystem.Memory
+{
+
+
+    public class MemoryDirectoryInfo : IDirectoryInfo
+    {
+        private readonly MemoryFileSystem _fileSystem;
+        private string _path;
+
+        public MemoryDirectoryInfo(MemoryFileSystem fileSystem, string path)
+        {
+            _fileSystem = fileSystem;
+            _path = path;
+        }
+
+        public FileAttributes Attributes
+    {
+        get
+        {
+            if (_fileSystem.FileSystemDictionary.TryGetValue(_path, out var entry))
+            {
+                return entry.Attributes;
+            }
+            throw new DirectoryNotFoundException($"Directory not found: {_path}");
+        }
+        set
+        {
+            if (_fileSystem.FileSystemDictionary.TryGetValue(_path, out var entry))
+            {
+                entry.Attributes = value;
+            }
+            else
+            {
+                throw new DirectoryNotFoundException($"Directory not found: {_path}");
+            }
+        }
+    }
+
+    public DateTime CreationTime
+    {
+        get
+        {
+            if (_fileSystem.FileSystemDictionary.TryGetValue(_path, out var entry))
+            {
+                return entry.CreationTime;
+            }
+            throw new DirectoryNotFoundException($"Directory not found: {_path}");
+        }
+        set
+        {
+            if (_fileSystem.FileSystemDictionary.TryGetValue(_path, out var entry))
+            {
+                entry.CreationTime = value;
+            }
+            else
+            {
+                throw new DirectoryNotFoundException($"Directory not found: {_path}");
+            }
+        }
+    }
+
+    public string FullName => _path;
+
+    public string Name => Path.GetFileName(_path);
+
+    public IDirectoryInfo? Parent
+    {
+        get
+        {
+            string? parentPath = Path.GetDirectoryName(_path);
+            return parentPath != null ? new MemoryDirectoryInfo(_fileSystem, parentPath) : null;
+        }
+    }
+
+    public bool Exists => _fileSystem.FileSystemDictionary.ContainsKey(_path);
+
+        public string Extension => Path.GetExtension(_path);
+
+      
+
+        public DateTime LastAccessTime
+        {
+            get
+            {
+                if (_fileSystem.FileSystemDictionary.TryGetValue(_path, out var entry))
+                {
+                    return entry.LastAccessTime;
+                }
+                throw new DirectoryNotFoundException($"Directory not found: {_path}");
+            }
+            set
+            {
+                if (_fileSystem.FileSystemDictionary.TryGetValue(_path, out var entry))
+                {
+                    entry.LastAccessTime = value;
+                }
+                else
+                {
+                    throw new DirectoryNotFoundException($"Directory not found: {_path}");
+                }
+            }
+        }
+
+        public DateTime LastAccessTimeUtc
+        {
+            get => LastAccessTime.ToUniversalTime();
+            set => LastAccessTime = value.ToLocalTime();
+        }
+
+        public DateTime LastWriteTime
+        {
+            get
+            {
+                if (_fileSystem.FileSystemDictionary.TryGetValue(_path, out var entry))
+                {
+                    return entry.LastWriteTime;
+                }
+                throw new DirectoryNotFoundException($"Directory not found: {_path}");
+            }
+            set
+            {
+                if (_fileSystem.FileSystemDictionary.TryGetValue(_path, out var entry))
+                {
+                    entry.LastWriteTime = value;
+                }
+                else
+                {
+                    throw new DirectoryNotFoundException($"Directory not found: {_path}");
+                }
+            }
+        }
+
+        public DateTime LastWriteTimeUtc
+        {
+            get => LastWriteTime.ToUniversalTime();
+            set => LastWriteTime = value.ToLocalTime();
+        }
+
+      
+     
+
+        public IDirectoryInfo Root => new MemoryDirectoryInfo(_fileSystem, Path.GetPathRoot(_path) ?? string.Empty);
+
+        public IFileSystem FileSystem => throw new NotImplementedException();
+
+        public string? LinkTarget => throw new NotImplementedException();
+
+           public UnixFileMode UnixFileMode
+    {
+        get
+        {
+            if (_fileSystem.FileSystemDictionary.TryGetValue(_path, out var entry))
+            {
+                return entry.UnixFileMode;
+            }
+            throw new DirectoryNotFoundException($"Directory not found: {_path}");
+        }
+        set
+        {
+            if (_fileSystem.FileSystemDictionary.TryGetValue(_path, out var entry))
+            {
+                entry.UnixFileMode = value;
+            }
+            else
+            {
+                throw new DirectoryNotFoundException($"Directory not found: {_path}");
+            }
+        }
+    }
+        public DateTime CreationTimeUtc { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+        public void Create()
+    {
+        _fileSystem.Directory.CreateDirectory(_path);
+    }
+
+    public void Delete()
+    {
+        _fileSystem.Directory.Delete(_path);
+    }
+
+        public void CreateAsSymbolicLink(string pathToTarget)
+        {
+            if (string.IsNullOrEmpty(pathToTarget))
+            {
+                throw new ArgumentNullException(nameof(pathToTarget));
+            }
+
+            if (_fileSystem.FileSystemDictionary.ContainsKey(_path))
+            {
+                throw new IOException($"Cannot create '{_path}' because a file or directory with the same name already exists.");
+            }
+
+            // Normalize the target path
+            string normalizedTargetPath = _fileSystem.Path.GetFullPath(pathToTarget);
+
+            // Check if the target exists (optional, remove if you want to allow dangling symlinks)
+            if (!_fileSystem.FileSystemDictionary.ContainsKey(normalizedTargetPath))
+            {
+                throw new DirectoryNotFoundException($"Target directory not found: {normalizedTargetPath}");
+            }
+
+            // Create the symbolic link
+            var symlinkEntry = new MemoryDirectoryEntry
+            {
+                Name = _fileSystem.Path.GetFileName(_path),
+                FullName = _path,
+                CreationTime = DateTime.Now,
+                LastAccessTime = DateTime.Now,
+                LastWriteTime = DateTime.Now,
+                Attributes = FileAttributes.Directory | FileAttributes.ReparsePoint,
+                IsSymbolicLink = true,
+                SymbolicLinkTarget = normalizedTargetPath
+            };
+
+            _fileSystem.FileSystemDictionary[_path] = symlinkEntry;
+
+            // Add the symlink to its parent directory's children
+            string? parentPath = _fileSystem.Path.GetDirectoryName(_path);
+            if (_fileSystem.FileSystemDictionary.TryGetValue(parentPath ?? string.Empty, out var parentEntry) && parentEntry is MemoryDirectoryEntry parentDir)
+            {
+                parentDir.Children[symlinkEntry.Name] = symlinkEntry;
+            }
+        }
+
+        public IDirectoryInfo CreateSubdirectory(string path)
+        {
+            return _fileSystem.Directory.CreateDirectory(Path.Combine(_path, path));
+        }
+
+      
+        public void Delete(bool recursive)
+        {
+            _fileSystem.Directory.Delete(_path, recursive);
+        }
+
+        public IEnumerable<IDirectoryInfo> EnumerateDirectories()
+        {
+            return _fileSystem.Directory.EnumerateDirectories(_path).Select(dir => new MemoryDirectoryInfo(_fileSystem, dir));
+        }
+
+        public IEnumerable<IDirectoryInfo> EnumerateDirectories(string searchPattern)
+        {
+            return _fileSystem.Directory.EnumerateDirectories(_path, searchPattern).Select(dir => new MemoryDirectoryInfo(_fileSystem, dir));
+        }
+
+        public IEnumerable<IDirectoryInfo> EnumerateDirectories(string searchPattern, SearchOption searchOption)
+        {
+            return _fileSystem.Directory.EnumerateDirectories(_path, searchPattern, searchOption).Select(dir => new MemoryDirectoryInfo(_fileSystem, dir));
+        }
+
+        public IEnumerable<IDirectoryInfo> EnumerateDirectories(string searchPattern, EnumerationOptions enumerationOptions)
+        {
+            return _fileSystem.Directory.EnumerateDirectories(_path, searchPattern, enumerationOptions)
+                .Select(dir => new MemoryDirectoryInfo(_fileSystem, dir));
+        }
+
+        public IEnumerable<IFileInfo> EnumerateFiles()
+        {
+            return _fileSystem.Directory.EnumerateFiles(_path).Select(file => new MemoryFileInfo(_fileSystem, file));
+        }
+
+        public IEnumerable<IFileInfo> EnumerateFiles(string searchPattern)
+        {
+            return _fileSystem.Directory.EnumerateFiles(_path, searchPattern).Select(file => new MemoryFileInfo(_fileSystem, file));
+        }
+
+        public IEnumerable<IFileInfo> EnumerateFiles(string searchPattern, SearchOption searchOption)
+        {
+            return _fileSystem.Directory.EnumerateFiles(_path, searchPattern, searchOption).Select(file => new MemoryFileInfo(_fileSystem, file));
+        }
+
+        public IEnumerable<IFileInfo> EnumerateFiles(string searchPattern, EnumerationOptions enumerationOptions)
+        {
+            return _fileSystem.Directory.EnumerateFiles(_path, searchPattern, enumerationOptions)
+                .Select(file => new MemoryFileInfo(_fileSystem, file));
+        }
+
+        public IEnumerable<IFileSystemInfo> EnumerateFileSystemInfos()
+        {
+            return _fileSystem.Directory.EnumerateFileSystemEntries(_path).Select(entry =>
+                _fileSystem.FileSystemDictionary[entry] is MemoryDirectoryEntry
+                    ? (IFileSystemInfo)new MemoryDirectoryInfo(_fileSystem, entry)
+                    : new MemoryFileInfo(_fileSystem, entry));
+        }
+
+        public IEnumerable<IFileSystemInfo> EnumerateFileSystemInfos(string searchPattern)
+        {
+            return _fileSystem.Directory.EnumerateFileSystemEntries(_path, searchPattern).Select(entry =>
+                _fileSystem.FileSystemDictionary[entry] is MemoryDirectoryEntry
+                    ? (IFileSystemInfo)new MemoryDirectoryInfo(_fileSystem, entry)
+                    : new MemoryFileInfo(_fileSystem, entry));
+        }
+
+        public IEnumerable<IFileSystemInfo> EnumerateFileSystemInfos(string searchPattern, SearchOption searchOption)
+        {
+            return _fileSystem.Directory.EnumerateFileSystemEntries(_path, searchPattern, searchOption).Select(entry =>
+                _fileSystem.FileSystemDictionary[entry] is MemoryDirectoryEntry
+                    ? (IFileSystemInfo)new MemoryDirectoryInfo(_fileSystem, entry)
+                    : new MemoryFileInfo(_fileSystem, entry));
+        }
+
+        public IEnumerable<IFileSystemInfo> EnumerateFileSystemInfos(string searchPattern, EnumerationOptions enumerationOptions)
+        {
+            return _fileSystem.Directory.EnumerateFileSystemEntries(_path, searchPattern, enumerationOptions)
+                .Select(entry => CreateFileSystemInfo(entry));
+        }
+
+        private IFileSystemInfo CreateFileSystemInfo(string path)
+        {
+            if (_fileSystem.FileSystemDictionary.TryGetValue(path, out var entry))
+            {
+                if (entry is MemoryDirectoryEntry)
+                {
+                    return new MemoryDirectoryInfo(_fileSystem, path);
+                }
+                else if (entry is MemoryFileEntry)
+                {
+                    return new MemoryFileInfo(_fileSystem, path);
+                }
+            }
+
+            // This should not happen in a properly maintained in-memory file system,
+            // but we'll handle it just in case
+            throw new FileNotFoundException($"File or directory not found: {path}");
+        }
+
+        public IDirectoryInfo[] GetDirectories()
+        {
+            return EnumerateDirectories().ToArray();
+        }
+
+        public IDirectoryInfo[] GetDirectories(string searchPattern)
+        {
+            return EnumerateDirectories(searchPattern).ToArray();
+        }
+
+        public IDirectoryInfo[] GetDirectories(string searchPattern, SearchOption searchOption)
+        {
+            return EnumerateDirectories(searchPattern, searchOption).ToArray();
+        }
+
+        public IDirectoryInfo[] GetDirectories(string searchPattern, EnumerationOptions enumerationOptions)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IFileInfo[] GetFiles()
+        {
+            return EnumerateFiles().ToArray();
+        }
+
+        public IFileInfo[] GetFiles(string searchPattern)
+        {
+            return EnumerateFiles(searchPattern).ToArray();
+        }
+
+        public IFileInfo[] GetFiles(string searchPattern, SearchOption searchOption)
+        {
+            return EnumerateFiles(searchPattern, searchOption).ToArray();
+        }
+
+        public IFileInfo[] GetFiles(string searchPattern, EnumerationOptions enumerationOptions)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IFileSystemInfo[] GetFileSystemInfos()
+        {
+            return EnumerateFileSystemInfos().ToArray();
+        }
+
+        public IFileSystemInfo[] GetFileSystemInfos(string searchPattern)
+        {
+            return EnumerateFileSystemInfos(searchPattern).ToArray();
+        }
+
+        public IFileSystemInfo[] GetFileSystemInfos(string searchPattern, SearchOption searchOption)
+        {
+            return EnumerateFileSystemInfos(searchPattern, searchOption).ToArray();
+        }
+
+        public IFileSystemInfo[] GetFileSystemInfos(string searchPattern, EnumerationOptions enumerationOptions)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void MoveTo(string destDirName)
+        {
+            _fileSystem.Directory.Move(_path, destDirName);
+            _path = destDirName;
+        }
+
+        public void Refresh()
+        {
+            // In an in-memory file system, this method doesn't need to do anything
+            // as the information is always up-to-date
+        }
+
+        public IFileSystemInfo? ResolveLinkTarget(bool returnFinalTarget)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemInfo ToFileSystemInfo()
+        {
+            throw new NotImplementedException("Converting to FileSystemInfo is not supported in the in-memory file system.");
+        }
+    }
+}

qdr.fnd.core/IO/FileSystem/Memory/MemoryFile.cs

@@ -0,0 +1,502 @@
+using Microsoft.Win32.SafeHandles;
+using Quadarax.Foundation.Core.IO.FileSystem.Memory;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Abstractions;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+namespace Quadarax.Foundation.Core.IO.FileSystem.Memory
+{
+
+    public class MemoryFile : IFile
+    {
+        private readonly MemoryFileSystem _fileSystem;
+
+        public IFileSystem FileSystem => throw new NotImplementedException();
+
+        public MemoryFile(MemoryFileSystem fileSystem)
+        {
+            _fileSystem = fileSystem;
+        }
+
+        public void AppendAllText(string path, string? contents)
+        {
+            if (!_fileSystem.FileSystemDictionary.TryGetValue(path, out var entry) || !(entry is MemoryFileEntry fileEntry))
+            {
+                throw new FileNotFoundException();
+            }
+
+            fileEntry.Content = Encoding.UTF8.GetBytes(Encoding.UTF8.GetString(fileEntry.Content) + contents);
+            fileEntry.LastWriteTime = DateTime.Now;
+        }
+
+        public void WriteAllText(string path, string? contents)
+        {
+            var fileEntry = new MemoryFileEntry
+            {
+                Name = Path.GetFileName(path),
+                FullName = path,
+                CreationTime = DateTime.Now,
+                LastAccessTime = DateTime.Now,
+                LastWriteTime = DateTime.Now,
+                Content = Encoding.UTF8.GetBytes(contents ?? string.Empty)
+            };
+
+            _fileSystem.FileSystemDictionary[path] = fileEntry;
+        }
+
+        public string ReadAllText(string path)
+        {
+            if (!_fileSystem.FileSystemDictionary.TryGetValue(path, out var entry) || !(entry is MemoryFileEntry fileEntry))
+            {
+                throw new FileNotFoundException();
+            }
+
+            fileEntry.LastAccessTime = DateTime.Now;
+            return Encoding.UTF8.GetString(fileEntry.Content);
+        }
+
+        public bool Exists(string? path)
+        {
+            if (path == null)
+                return false;
+            
+            return _fileSystem.FileSystemDictionary.TryGetValue(path, out var entry) && entry is MemoryFileEntry;
+        }
+
+        public Task AppendAllLinesAsync(string path, IEnumerable<string> contents, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task AppendAllLinesAsync(string path, IEnumerable<string> contents, Encoding encoding, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task AppendAllTextAsync(string path, string? contents, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task AppendAllTextAsync(string path, string? contents, Encoding encoding, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<byte[]> ReadAllBytesAsync(string path, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<string[]> ReadAllLinesAsync(string path, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<string[]> ReadAllLinesAsync(string path, Encoding encoding, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<string> ReadAllTextAsync(string path, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<string> ReadAllTextAsync(string path, Encoding encoding, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IAsyncEnumerable<string> ReadLinesAsync(string path, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IAsyncEnumerable<string> ReadLinesAsync(string path, Encoding encoding, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task WriteAllBytesAsync(string path, byte[] bytes, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task WriteAllLinesAsync(string path, IEnumerable<string> contents, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task WriteAllLinesAsync(string path, IEnumerable<string> contents, Encoding encoding, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task WriteAllTextAsync(string path, string? contents, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task WriteAllTextAsync(string path, string? contents, Encoding encoding, CancellationToken cancellationToken = default)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void AppendAllLines(string path, IEnumerable<string> contents)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void AppendAllLines(string path, IEnumerable<string> contents, Encoding encoding)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void AppendAllText(string path, string? contents, Encoding encoding)
+        {
+            throw new NotImplementedException();
+        }
+
+        public StreamWriter AppendText(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Copy(string sourceFileName, string destFileName)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Copy(string sourceFileName, string destFileName, bool overwrite)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream Create(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream Create(string path, int bufferSize)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream Create(string path, int bufferSize, FileOptions options)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IFileSystemInfo CreateSymbolicLink(string path, string pathToTarget)
+        {
+            throw new NotImplementedException();
+        }
+
+        public StreamWriter CreateText(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Decrypt(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Delete(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Encrypt(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileAttributes GetAttributes(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileAttributes GetAttributes(SafeFileHandle fileHandle)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetCreationTime(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetCreationTime(SafeFileHandle fileHandle)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetCreationTimeUtc(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetCreationTimeUtc(SafeFileHandle fileHandle)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetLastAccessTime(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetLastAccessTime(SafeFileHandle fileHandle)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetLastAccessTimeUtc(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetLastAccessTimeUtc(SafeFileHandle fileHandle)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetLastWriteTime(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetLastWriteTime(SafeFileHandle fileHandle)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetLastWriteTimeUtc(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public DateTime GetLastWriteTimeUtc(SafeFileHandle fileHandle)
+        {
+            throw new NotImplementedException();
+        }
+
+        public UnixFileMode GetUnixFileMode(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public UnixFileMode GetUnixFileMode(SafeFileHandle fileHandle)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Move(string sourceFileName, string destFileName)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Move(string sourceFileName, string destFileName, bool overwrite)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream Open(string path, FileMode mode)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream Open(string path, FileMode mode, FileAccess access)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream Open(string path, FileMode mode, FileAccess access, FileShare share)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream Open(string path, FileStreamOptions options)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream OpenRead(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public StreamReader OpenText(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream OpenWrite(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public byte[] ReadAllBytes(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string[] ReadAllLines(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string[] ReadAllLines(string path, Encoding encoding)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string ReadAllText(string path, Encoding encoding)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerable<string> ReadLines(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerable<string> ReadLines(string path, Encoding encoding)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Replace(string sourceFileName, string destinationFileName, string? destinationBackupFileName)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Replace(string sourceFileName, string destinationFileName, string? destinationBackupFileName, bool ignoreMetadataErrors)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IFileSystemInfo? ResolveLinkTarget(string linkPath, bool returnFinalTarget)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetAttributes(string path, FileAttributes fileAttributes)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetAttributes(SafeFileHandle fileHandle, FileAttributes fileAttributes)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetCreationTime(string path, DateTime creationTime)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetCreationTime(SafeFileHandle fileHandle, DateTime creationTime)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetCreationTimeUtc(string path, DateTime creationTimeUtc)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetCreationTimeUtc(SafeFileHandle fileHandle, DateTime creationTimeUtc)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetLastAccessTime(string path, DateTime lastAccessTime)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetLastAccessTime(SafeFileHandle fileHandle, DateTime lastAccessTime)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetLastAccessTimeUtc(string path, DateTime lastAccessTimeUtc)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetLastAccessTimeUtc(SafeFileHandle fileHandle, DateTime lastAccessTimeUtc)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetLastWriteTime(string path, DateTime lastWriteTime)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetLastWriteTime(SafeFileHandle fileHandle, DateTime lastWriteTime)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetLastWriteTimeUtc(string path, DateTime lastWriteTimeUtc)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetLastWriteTimeUtc(SafeFileHandle fileHandle, DateTime lastWriteTimeUtc)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetUnixFileMode(string path, UnixFileMode mode)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetUnixFileMode(SafeFileHandle fileHandle, UnixFileMode mode)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void WriteAllBytes(string path, byte[] bytes)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void WriteAllLines(string path, string[] contents)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void WriteAllLines(string path, IEnumerable<string> contents)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void WriteAllLines(string path, string[] contents, Encoding encoding)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void WriteAllLines(string path, IEnumerable<string> contents, Encoding encoding)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void WriteAllText(string path, string? contents, Encoding encoding)
+        {
+            throw new NotImplementedException();
+        }
+
+        // Implement other methods as needed
+    }
+
+}

qdr.fnd.core/IO/FileSystem/Memory/MemoryFileEntry.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Quadarax.Foundation.Core.IO.FileSystem.Memory
+{
+    internal class MemoryFileEntry : MemoryFileSystemEntry
+    {
+        public byte[] Content { get; set; } = Array.Empty<byte>();
+    }
+}

qdr.fnd.core/IO/FileSystem/Memory/MemoryFileInfo.cs

@@ -0,0 +1,232 @@
+using Quadarax.Foundation.Core.IO.FileSystem.Memory;
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.IO.Abstractions;
+namespace Quadarax.Foundation.Core.IO.FileSystem.Memory
+{
+
+    public class MemoryFileInfo : IFileInfo
+    {
+        private readonly MemoryFileSystem _fileSystem;
+        private readonly string _path;
+
+        public MemoryFileInfo(MemoryFileSystem fileSystem, string path)
+        {
+            _fileSystem = fileSystem;
+            _path = path;
+        }
+
+         public bool Exists => _fileSystem.FileSystemDictionary.ContainsKey(_path);
+
+    public string Name => Path.GetFileName(_path);
+
+    public string FullName => _path;
+
+    public bool IsSymbolicLink
+    {
+        get
+        {
+            if (_fileSystem.FileSystemDictionary.TryGetValue(_path, out var entry))
+            {
+                return entry.IsSymbolicLink;
+            }
+            return false;
+        }
+    }
+
+    public string? LinkTarget
+    {
+        get
+        {
+            if (_fileSystem.FileSystemDictionary.TryGetValue(_path, out var entry) && entry.IsSymbolicLink)
+            {
+                return entry.SymbolicLinkTarget;
+            }
+            return null;
+        }
+    }
+
+        public IDirectoryInfo? Directory => throw new NotImplementedException();
+
+        public string? DirectoryName => throw new NotImplementedException();
+
+        public bool IsReadOnly { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+        public long Length => throw new NotImplementedException();
+
+        public IFileSystem FileSystem => throw new NotImplementedException();
+
+        public FileAttributes Attributes { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public DateTime CreationTime { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public DateTime CreationTimeUtc { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+        public string Extension => throw new NotImplementedException();
+
+        public DateTime LastAccessTime { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public DateTime LastAccessTimeUtc { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public DateTime LastWriteTime { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public DateTime LastWriteTimeUtc { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+        public UnixFileMode UnixFileMode { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+        public StreamWriter AppendText()
+        {
+            throw new NotImplementedException();
+        }
+
+        public IFileInfo CopyTo(string destFileName)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IFileInfo CopyTo(string destFileName, bool overwrite)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream Create()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void CreateAsSymbolicLink(string pathToTarget)
+        {
+            throw new NotImplementedException();
+        }
+
+        public StreamWriter CreateText()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Decrypt()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Delete()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Encrypt()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void MoveTo(string destFileName)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void MoveTo(string destFileName, bool overwrite)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream Open(FileMode mode)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream Open(FileMode mode, FileAccess access)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream Open(FileMode mode, FileAccess access, FileShare share)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream Open(FileStreamOptions options)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream OpenRead()
+        {
+            throw new NotImplementedException();
+        }
+
+        public StreamReader OpenText()
+        {
+            throw new NotImplementedException();
+        }
+
+        public FileSystemStream OpenWrite()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Refresh()
+        {
+            throw new NotImplementedException();
+        }
+
+        public IFileInfo Replace(string destinationFileName, string? destinationBackupFileName)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IFileInfo Replace(string destinationFileName, string? destinationBackupFileName, bool ignoreMetadataErrors)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IFileSystemInfo? ResolveLinkTarget(bool returnFinalTarget)
+        {
+            throw new NotImplementedException();
+        }
+
+        // Implement other properties and methods as needed
+    }
+
+   
+    public class MemoryFileInfoFactory : IFileInfoFactory
+    {
+        private readonly MemoryFileSystem _fileSystem;
+
+        public MemoryFileInfoFactory(MemoryFileSystem fileSystem)
+        {
+            _fileSystem = fileSystem;
+        }
+
+        public IFileSystem FileSystem => throw new NotImplementedException();
+
+        public IFileInfo New(string fileName)
+        {
+            return new MemoryFileInfo(_fileSystem, fileName);
+        }
+
+        [return: NotNullIfNotNull("fileInfo")]
+        public IFileInfo? Wrap(FileInfo? fileInfo)
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+    public class MemoryDirectoryInfoFactory : IDirectoryInfoFactory
+    {
+        private readonly MemoryFileSystem _fileSystem;
+
+        public MemoryDirectoryInfoFactory(MemoryFileSystem fileSystem)
+        {
+            _fileSystem = fileSystem;
+        }
+
+        public IFileSystem FileSystem => throw new NotImplementedException();
+
+        public IDirectoryInfo New(string path)
+        {
+            return new MemoryDirectoryInfo(_fileSystem, path);
+        }
+
+        [return: NotNullIfNotNull("directoryInfo")]
+        public IDirectoryInfo? Wrap(DirectoryInfo? directoryInfo)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

qdr.fnd.core/IO/FileSystem/Memory/MemoryFileSystem.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Abstractions;
+namespace Quadarax.Foundation.Core.IO.FileSystem.Memory
+{
+    public class MemoryFileSystem : IFileSystem
+    {
+        private readonly Dictionary<string, MemoryFileSystemEntry> _fileSystem;
+
+        public MemoryFileSystem()
+        {
+            _fileSystem = new Dictionary<string, MemoryFileSystemEntry>(StringComparer.OrdinalIgnoreCase);
+            File = new MemoryFile(this);
+            Directory = new MemoryDirectory(this);
+            Path = new MemoryPath(this);
+            FileInfo = new MemoryFileInfoFactory(this);
+            DirectoryInfo = new MemoryDirectoryInfoFactory(this);
+        }
+
+        public IFile File { get; }
+        public IDirectory Directory { get; }
+        public IPath Path { get; }
+        public IFileInfoFactory FileInfo { get; }
+        public IDirectoryInfoFactory DirectoryInfo { get; }
+
+        public IDriveInfoFactory DriveInfo => throw new NotImplementedException();
+
+        public IFileStreamFactory FileStream => throw new NotImplementedException();
+
+        public IFileSystemWatcherFactory FileSystemWatcher => throw new NotImplementedException();
+
+        // Implement other properties as needed
+
+        internal Dictionary<string, MemoryFileSystemEntry> FileSystemDictionary => _fileSystem;
+
+        IFileVersionInfoFactory IFileSystem.FileVersionInfo => throw new NotImplementedException();
+
+        internal MemoryFileSystemEntry? ResolveSymbolicLink(MemoryFileSystemEntry entry)
+        {
+            int maxSymlinkDepth = 40; // Prevent infinite loops
+            while (entry.IsSymbolicLink && maxSymlinkDepth > 0)
+            {
+                if (FileSystemDictionary.TryGetValue(entry.SymbolicLinkTarget, out var targetEntry))
+                {
+                    entry = targetEntry;
+                    maxSymlinkDepth--;
+                }
+                else
+                {
+                    // Broken symlink
+                    return null;
+                }
+            }
+
+            if (maxSymlinkDepth == 0)
+            {
+                throw new IOException("Too many levels of symbolic links");
+            }
+
+            return entry;
+        }
+    }
+
+}

qdr.fnd.core/IO/FileSystem/Memory/MemoryFileSystemEntry.cs

@@ -0,0 +1,18 @@
+using System;
+using System.IO;
+
+namespace Quadarax.Foundation.Core.IO.FileSystem.Memory
+{
+    internal abstract class MemoryFileSystemEntry
+{
+    public string Name { get; set; } = string.Empty;
+        public string FullName { get; set; } = string.Empty;
+    public DateTime CreationTime { get; set; }
+    public DateTime LastAccessTime { get; set; }
+    public DateTime LastWriteTime { get; set; }
+    public FileAttributes Attributes { get; set; }
+    public UnixFileMode UnixFileMode { get; set; }
+    public bool IsSymbolicLink { get; set; }
+    public string SymbolicLinkTarget { get; set; } = string.Empty;
+}
+}

qdr.fnd.core/IO/FileSystem/Memory/MemoryPath.cs

@@ -0,0 +1,249 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.IO.Abstractions;
+namespace Quadarax.Foundation.Core.IO.FileSystem.Memory
+{
+
+    public class MemoryPath : IPath
+    {
+        private readonly MemoryFileSystem _fileSystem;
+        private readonly string _tempPath;
+
+        public char DirectorySeparatorChar => Path.DirectorySeparatorChar;
+        public char AltDirectorySeparatorChar => Path.AltDirectorySeparatorChar;
+
+        public char PathSeparator => throw new NotImplementedException();
+
+        public char VolumeSeparatorChar => throw new NotImplementedException();
+
+        public IFileSystem FileSystem => _fileSystem;
+
+
+        public MemoryPath(MemoryFileSystem fileSystem)
+        {
+            _fileSystem = fileSystem;
+            _tempPath = System.IO.Path.GetTempPath(); // Use the real system's temp path
+        }
+
+        [return: NotNullIfNotNull("path")]
+        public string? ChangeExtension(string? path, string? extension)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string Combine(string path1, string path2)
+        {
+            return Path.Combine(path1, path2);
+        }
+
+        public string Combine(string path1, string path2, string path3)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string Combine(string path1, string path2, string path3, string path4)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string Combine(params string[] paths)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool EndsInDirectorySeparator(ReadOnlySpan<char> path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool EndsInDirectorySeparator(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Exists([NotNullWhen(true)] string? path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string? GetDirectoryName(string? path)
+        {
+            return Path.GetDirectoryName(path);
+        }
+
+        public ReadOnlySpan<char> GetDirectoryName(ReadOnlySpan<char> path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ReadOnlySpan<char> GetExtension(ReadOnlySpan<char> path)
+        {
+            throw new NotImplementedException();
+        }
+
+        [return: NotNullIfNotNull("path")]
+        public string? GetExtension(string? path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string? GetFileName(string? path)
+        {
+            return Path.GetFileName(path);
+        }
+
+        public ReadOnlySpan<char> GetFileName(ReadOnlySpan<char> path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ReadOnlySpan<char> GetFileNameWithoutExtension(ReadOnlySpan<char> path)
+        {
+            throw new NotImplementedException();
+        }
+
+        [return: NotNullIfNotNull("path")]
+        public string? GetFileNameWithoutExtension(string? path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string GetFullPath(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string GetFullPath(string path, string basePath)
+        {
+            throw new NotImplementedException();
+        }
+
+        public char[] GetInvalidFileNameChars()
+        {
+            throw new NotImplementedException();
+        }
+
+        public char[] GetInvalidPathChars()
+        {
+            throw new NotImplementedException();
+        }
+
+        public ReadOnlySpan<char> GetPathRoot(ReadOnlySpan<char> path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string? GetPathRoot(string? path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string GetRandomFileName()
+        {
+            throw new NotImplementedException();
+        }
+
+        public string GetRelativePath(string relativeTo, string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string GetTempFileName()
+        {
+            throw new NotImplementedException();
+        }
+
+        public string GetTempPath()
+        {
+            return _tempPath;
+        }
+
+        public bool HasExtension(ReadOnlySpan<char> path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool HasExtension([NotNullWhen(true)] string? path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsPathFullyQualified(ReadOnlySpan<char> path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsPathFullyQualified(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsPathRooted(ReadOnlySpan<char> path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsPathRooted([NotNullWhen(true)] string? path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string Join(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string Join(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string Join(string? path1, string? path2)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string Join(string? path1, string? path2, string? path3)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string Join(params string?[] paths)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string Join(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3, ReadOnlySpan<char> path4)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string Join(string? path1, string? path2, string? path3, string? path4)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ReadOnlySpan<char> TrimEndingDirectorySeparator(ReadOnlySpan<char> path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string TrimEndingDirectorySeparator(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool TryJoin(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, Span<char> destination, out int charsWritten)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool TryJoin(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3, Span<char> destination, out int charsWritten)
+        {
+            throw new NotImplementedException();
+        }
+
+        // Implement other methods as needed
+    }
+}

qdr.fnd.core/Json/Binder.cs

@@ -28,12 +28,13 @@ namespace Quadarax.Foundation.Core.Json
             _fileSystem = fileSystemAbstraction ?? throw new ArgumentNullException(nameof(fileSystemAbstraction));
             var jsonOpt = new JsonSerializerOptions
             {
-                IgnoreNullValues = isIgnoringNullValues,
                 WriteIndented = isPrettyPrint,
                 PropertyNameCaseInsensitive = true,
                 PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                 MaxDepth = maxDepth
             };
+            if (isIgnoringNullValues)
+                jsonOpt.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
             jsonOpt.Converters.Add(new JsonStringEnumConverter());
             SerializerOptions = jsonOpt;
         }

qdr.fnd.core/qdr.fnd.core.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>..\bo_strong_key_pair.snk</AssemblyOriginatorKeyFile>
     <DelaySign>false</DelaySign>
@@ -12,16 +12,15 @@
     <Company>Quadarax</Company>
     <Product>Quadarax.Foundation</Product>
     <Description>Core library with general pattern implementations and patterns</Description>
-    <Copyright>Copyright © 2023,2024 Quadarax</Copyright>
+    <Copyright>Copyright © 2023,2024,2025 Quadarax</Copyright>
     <PackageIcon>quadarax_dll.png</PackageIcon>
     <PackageTags>QDR;FND;CORE</PackageTags>
-    <AssemblyVersion>0.0.5.0</AssemblyVersion>
-    <FileVersion>0.0.5.0</FileVersion>
-    <Version>0.0.5.0-alpha</Version>
-    <PackageReleaseNotes>Date:26.9.2024
-      - improve class CsvHelper to support with quoted values, add operation to write DataTable to CSV file.
-	  - extends ParametrizedString to set parametr value.
-      - update dependencies packages (System.IO.Abstractions)
+    <AssemblyVersion>0.0.6.0</AssemblyVersion>
+    <FileVersion>0.0.6.0</FileVersion>
+    <Version>0.0.6.0-alpha</Version>
+    <PackageReleaseNotes>Date:7.1.2025
+		- update to .NET 9.0
+		- update dependencies packages (System.IO.Abstractions)
     </PackageReleaseNotes>
     <PackageReadmeFile>releasenotes.md</PackageReadmeFile>
     <Nullable>enable</Nullable>
@@ -47,7 +46,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="System.IO.Abstractions" Version="21.0.29" />
+    <PackageReference Include="System.IO.Abstractions" Version="21.2.1" />
   </ItemGroup>
 
   <ItemGroup>

qdr.fnd.core/qdr.fnd.core.csproj.Backup.tmp

@@ -0,0 +1,60 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>..\bo_strong_key_pair.snk</AssemblyOriginatorKeyFile>
+    <DelaySign>false</DelaySign>
+    <RootNamespace>Quadarax.Foundation.Core</RootNamespace>
+    <ApplicationIcon>..\quadarax_dll.ico</ApplicationIcon>
+    <Title>Quadarax.Foundation.Core</Title>
+    <Authors>Dalibor Votruba</Authors>
+    <Company>Quadarax</Company>
+    <Product>Quadarax.Foundation</Product>
+    <Description>Core library with general pattern implementations and patterns</Description>
+    <Copyright>Copyright © 2023,2024 Quadarax</Copyright>
+    <PackageIcon>quadarax_dll.png</PackageIcon>
+    <PackageTags>QDR;FND;CORE</PackageTags>
+    <AssemblyVersion>0.0.5.0</AssemblyVersion>
+    <FileVersion>0.0.5.0</FileVersion>
+    <Version>0.0.5.0-alpha</Version>
+    <PackageReleaseNotes>Date:26.9.2024
+      - improve class CsvHelper to support with quoted values, add operation to write DataTable to CSV file.
+	  - extends ParametrizedString to set parametr value.
+      - update dependencies packages (System.IO.Abstractions)
+    </PackageReleaseNotes>
+    <PackageReadmeFile>releasenotes.md</PackageReadmeFile>
+    <Nullable>enable</Nullable>
+
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Content Include="releasenotes.md">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Data\Extensions\" />
+    <Folder Include="Mapper\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="..\quadarax_dll.png">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.IO.Abstractions" Version="21.2.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="releasenotes.md">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
+</Project>

qdr.fnd.core/releasenotes.md

@@ -1,6 +1,12 @@
 # Quadarax.Foundation.Core * Release notes
 Ordered by version descending
 
+## 0.0.6.0
+Date:__7.1.2025__
+- update to .NET 9.0
+- update dependencies packages (System.IO.Abstractions)
+---
+
 ## 0.0.5.0
 Date:__26.9.2024__
 - improve class CsvHelper to support with quoted values, add operation to write DataTable to CSV file.