From d132a6cafcf1cbb75c1d356701685e5370cb8946 Mon Sep 17 00:00:00 2001
From: Edgar Mesquita <edgar@equantic.tech>
Date: Mon, 20 Jul 2026 19:00:13 +0100
Subject: [PATCH 1/2] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20refactor:=20extract=20?=
 =?UTF-8?q?a=20shared=20EntityFrameworkUnitOfWork=20base=20for=20the=20doc?=
 =?UTF-8?q?ument=20providers?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The MongoDb and (incoming) CosmosDb unit of works were near-identical copies of the same ~200 lines of store-agnostic IQueryableUnitOfWork boilerplate (Commit, GetRepository, ApplyCurrentValues, LoadCollection, Dispose, ...). Extracts that into an abstract EntityFrameworkUnitOfWork in the base package, with a single abstract CreateSetCore<TEntity>() each provider overrides to build its own Set. MongoDb's unit of work drops to ~15 lines. The relational providers keep RelationalUnitOfWork (it also is a raw-SQL executor, a separate concern). Behaviour is unchanged; base/Relational/SqlServer/MongoDb build and all 30 tests pass.
---
 .../Repository/UnitOfWork.cs                  | 240 +----------------
 .../Repository/EntityFrameworkUnitOfWork.cs   | 249 ++++++++++++++++++
 2 files changed, 257 insertions(+), 232 deletions(-)
 create mode 100644 src/eQuantic.Core.Data.EntityFramework/Repository/EntityFrameworkUnitOfWork.cs

diff --git a/src/eQuantic.Core.Data.EntityFramework.MongoDb/Repository/UnitOfWork.cs b/src/eQuantic.Core.Data.EntityFramework.MongoDb/Repository/UnitOfWork.cs
index 8e38967..9da4ad4 100644
--- a/src/eQuantic.Core.Data.EntityFramework.MongoDb/Repository/UnitOfWork.cs
+++ b/src/eQuantic.Core.Data.EntityFramework.MongoDb/Repository/UnitOfWork.cs
@@ -1,243 +1,19 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
+using eQuantic.Core.Data.EntityFramework.Repository;
 using eQuantic.Core.Data.Repository;
-using eQuantic.Core.Data.Repository.Options;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.DependencyInjection;
 
 namespace eQuantic.Core.Data.EntityFramework.MongoDb.Repository;
 
-public abstract class UnitOfWork : IQueryableUnitOfWork
+/// <summary>
+///     The MongoDB unit of work. All of the store-agnostic behaviour lives in
+///     <see cref="EntityFrameworkUnitOfWork" />; this only supplies the MongoDB <see cref="Set{TEntity}" />.
+/// </summary>
+public abstract class UnitOfWork(IServiceProvider serviceProvider, DbContext context)
+    : EntityFrameworkUnitOfWork(serviceProvider, context)
 {
-    protected readonly IServiceProvider ServiceProvider;
-    /// <summary>
-    ///     The context
-    /// </summary>
-    protected readonly DbContext Context;
-
-    /// <summary>
-    ///     The disposed
-    /// </summary>
-    protected bool Disposed;
-
-    /// <summary>
-    ///     Initializes a new instance of the class
-    /// </summary>
-    /// <param name="serviceProvider"></param>
-    /// <param name="context">The context</param>
-    protected UnitOfWork(IServiceProvider serviceProvider, DbContext context)
-    {
-        ServiceProvider = serviceProvider;
-        Context = context;
-    }
-
-    public int Commit()
-    {
-        return Context.SaveChanges();
-    }
-
-    public int CommitAndRefreshChanges()
-    {
-        var changes = 0;
-        var saveFailed = false;
-
-        do
-        {
-            try
-            {
-                changes = Context.SaveChanges();
-
-                saveFailed = false;
-            }
-            catch (DbUpdateConcurrencyException ex)
-            {
-                saveFailed = true;
-
-                ex.Entries.ToList()
-                    .ForEach(entry => entry.OriginalValues.SetValues(entry.GetDatabaseValues()!));
-            }
-        } while (saveFailed);
-
-        return changes;
-    }
-
-    public async Task<int> CommitAndRefreshChangesAsync(CancellationToken cancellationToken = default)
-    {
-        var changes = 0;
-        var saveFailed = false;
-
-        do
-        {
-            try
-            {
-                changes = await Context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
-
-                saveFailed = false;
-            }
-            catch (DbUpdateConcurrencyException ex)
-            {
-                saveFailed = true;
-
-                ex.Entries.ToList()
-                    .ForEach(entry => entry.OriginalValues.SetValues(entry.GetDatabaseValues()!));
-            }
-        } while (saveFailed);
-
-        return changes;
-    }
-
-    public async Task<int> CommitAsync(CancellationToken cancellationToken = default)
-    {
-        return await Context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
-    }
-
-    public int Commit(Action<SaveOptions> options)
-    {
-        return Commit();
-    }
-
-    public int CommitAndRefreshChanges(Action<SaveOptions> options)
-    {
-        return CommitAndRefreshChanges();
-    }
-
-    public Task<int> CommitAndRefreshChangesAsync(Action<SaveOptions> options, CancellationToken cancellationToken = default)
-    {
-        return CommitAndRefreshChangesAsync(cancellationToken);
-    }
-
-    public Task<int> CommitAsync(Action<SaveOptions> options, CancellationToken cancellationToken = default)
-    {
-        return CommitAsync(cancellationToken);
-    }
-
-    public void ApplyCurrentValues<TEntity>(TEntity original, TEntity current) where TEntity : class, IEntity
-    {
-        ((Set<TEntity>)InternalCreateSet<TEntity>()).ApplyCurrentValues(original, current);
-    }
-
-    public void Attach<TEntity>(TEntity item) where TEntity : class, IEntity
-    {
-        ((Set<TEntity>)InternalCreateSet<TEntity>()).Attach(item);
-    }
-
-    public void LoadCollection<TEntity, TElement>(TEntity item,
-        Expression<Func<TEntity, IEnumerable<TElement>>> navigationProperty,
-        Expression<Func<TElement, bool>>? filter = null) where TEntity : class where TElement : class
-    {
-        if (filter != null)
-        {
-            Context.Entry<TEntity>(item).Collection(navigationProperty).Query().Where(filter).Load();
-        }
-        else
-        {
-            Context.Entry<TEntity>(item).Collection(navigationProperty).Load();
-        }
-    }
-
-    public async Task LoadCollectionAsync<TEntity, TElement>(TEntity item,
-        Expression<Func<TEntity, IEnumerable<TElement>>> navigationProperty,
-        Expression<Func<TElement, bool>>? filter = null) where TEntity : class where TElement : class
-    {
-        if (filter != null)
-        {
-            await Context.Entry<TEntity>(item).Collection(navigationProperty).Query().Where(filter).LoadAsync().ConfigureAwait(false);
-        }
-        else
-        {
-            await Context.Entry<TEntity>(item).Collection(navigationProperty).LoadAsync().ConfigureAwait(false);
-        }
-    }
-
-    public void Reload<TEntity>(TEntity item) where TEntity : class
-    {
-        var entry = Context.Entry(item);
-        entry.CurrentValues.SetValues(entry.OriginalValues);
-        entry.Reload();
-    }
-
-    public void RollbackChanges()
-    {
-        // set all entities in change tracker
-        // as 'unchanged state'
-        Context?.ChangeTracker.Entries()
-            .ToList()
-            .ForEach(entry => entry.State = EntityState.Unchanged);
-    }
-
-    public void SetModified<TEntity>(TEntity item) where TEntity : class
-    {
-        //this operation also attach item in object state manager
-        Context.Entry<TEntity>(item).State = EntityState.Modified;
-    }
-
-    public virtual SaveOptions GetSaveOptions()
-    {
-        return new SaveOptions();
-    }
-
-    public virtual IRepository<TEntity, TKey> GetRepository<TEntity, TKey>()
-        where TEntity : class, IEntity<TKey>
-    {
-        return ServiceProvider.GetRequiredService<IRepository<TEntity, TKey>>();
-    }
-
-    public IAsyncRepository<TEntity, TKey> GetAsyncRepository<TEntity, TKey>()
-        where TEntity : class, IEntity<TKey>
-    {
-        return ServiceProvider.GetRequiredService<IAsyncRepository<TEntity, TKey>>();
-    }
-
-    public Data.Repository.ISet<TEntity> CreateSet<TEntity>() where TEntity : class, IEntity => InternalCreateSet<TEntity>();
-
-    public IQueryableRepository<TEntity, TKey> GetQueryableRepository<TEntity, TKey>()
-        where TEntity : class, IEntity<TKey>
-    {
-        return ServiceProvider.GetRequiredService<IQueryableRepository<TEntity, TKey>>();
-    }
-
-    public IAsyncQueryableRepository<TEntity, TKey> GetAsyncQueryableRepository<TEntity, TKey>()
-        where TEntity : class, IEntity<TKey>
-    {
-        return ServiceProvider.GetRequiredService<IAsyncQueryableRepository<TEntity, TKey>>();
-    }
-
-    internal DbContext GetDbContext() => Context;
-
-    internal Data.Repository.ISet<TEntity> InternalCreateSet<TEntity>() where TEntity : class, IEntity =>
+    protected override Data.Repository.ISet<TEntity> CreateSetCore<TEntity>() =>
         new Set<TEntity>(ServiceProvider, Context);
-
-    /// <summary>
-    ///     Disposes this instance
-    /// </summary>
-    public void Dispose()
-    {
-        Dispose(true);
-        GC.SuppressFinalize(this);
-    }
-
-    /// <summary>
-    ///     Disposes the disposing
-    /// </summary>
-    /// <param name="disposing">The disposing</param>
-    protected virtual void Dispose(bool disposing)
-    {
-        if (Disposed)
-        {
-            return;
-        }
-
-        if (disposing)
-        {
-            Context?.Dispose();
-        }
-
-        Disposed = true;
-    }
 }
 
 public abstract class UnitOfWork<TDbContext>(IServiceProvider serviceProvider, TDbContext context)
diff --git a/src/eQuantic.Core.Data.EntityFramework/Repository/EntityFrameworkUnitOfWork.cs b/src/eQuantic.Core.Data.EntityFramework/Repository/EntityFrameworkUnitOfWork.cs
new file mode 100644
index 0000000..eaf8ecf
--- /dev/null
+++ b/src/eQuantic.Core.Data.EntityFramework/Repository/EntityFrameworkUnitOfWork.cs
@@ -0,0 +1,249 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+using eQuantic.Core.Data.Repository;
+using eQuantic.Core.Data.Repository.Options;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace eQuantic.Core.Data.EntityFramework.Repository;
+
+/// <summary>
+///     The shared, provider-agnostic <see cref="IQueryableUnitOfWork" /> implementation for the document
+///     (non-relational) EF Core providers. It carries every unit-of-work member that does not depend on the
+///     store; each provider supplies only its own entity set by overriding <see cref="CreateSetCore{TEntity}" />.
+///     The relational providers keep their own unit of work (it also is a raw-SQL executor).
+/// </summary>
+public abstract class EntityFrameworkUnitOfWork : IQueryableUnitOfWork
+{
+    /// <summary>The service provider used to resolve repositories.</summary>
+    protected readonly IServiceProvider ServiceProvider;
+
+    /// <summary>The underlying <see cref="DbContext" />.</summary>
+    protected readonly DbContext Context;
+
+    /// <summary>Whether this instance has been disposed.</summary>
+    protected bool Disposed;
+
+    /// <summary>Initializes a new instance of the <see cref="EntityFrameworkUnitOfWork" /> class.</summary>
+    /// <param name="serviceProvider">The service provider.</param>
+    /// <param name="context">The context.</param>
+    protected EntityFrameworkUnitOfWork(IServiceProvider serviceProvider, DbContext context)
+    {
+        ServiceProvider = serviceProvider;
+        Context = context;
+    }
+
+    /// <summary>Creates the provider-specific entity set for <typeparamref name="TEntity" />.</summary>
+    /// <typeparam name="TEntity">The entity type.</typeparam>
+    /// <returns>The provider's <see cref="Data.Repository.ISet{TEntity}" /> (a <see cref="SetBase{TEntity}" />).</returns>
+    protected abstract Data.Repository.ISet<TEntity> CreateSetCore<TEntity>() where TEntity : class, IEntity;
+
+    public int Commit()
+    {
+        return Context.SaveChanges();
+    }
+
+    public int CommitAndRefreshChanges()
+    {
+        var changes = 0;
+        var saveFailed = false;
+
+        do
+        {
+            try
+            {
+                changes = Context.SaveChanges();
+
+                saveFailed = false;
+            }
+            catch (DbUpdateConcurrencyException ex)
+            {
+                saveFailed = true;
+
+                ex.Entries.ToList()
+                    .ForEach(entry => entry.OriginalValues.SetValues(entry.GetDatabaseValues()));
+            }
+        } while (saveFailed);
+
+        return changes;
+    }
+
+    public async Task<int> CommitAndRefreshChangesAsync(CancellationToken cancellationToken = default)
+    {
+        var changes = 0;
+        var saveFailed = false;
+
+        do
+        {
+            try
+            {
+                changes = await Context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+
+                saveFailed = false;
+            }
+            catch (DbUpdateConcurrencyException ex)
+            {
+                saveFailed = true;
+
+                ex.Entries.ToList()
+                    .ForEach(entry => entry.OriginalValues.SetValues(entry.GetDatabaseValues()));
+            }
+        } while (saveFailed);
+
+        return changes;
+    }
+
+    public async Task<int> CommitAsync(CancellationToken cancellationToken = default)
+    {
+        return await Context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+    }
+
+    public int Commit(Action<SaveOptions> options)
+    {
+        return Commit();
+    }
+
+    public int CommitAndRefreshChanges(Action<SaveOptions> options)
+    {
+        return CommitAndRefreshChanges();
+    }
+
+    public Task<int> CommitAndRefreshChangesAsync(Action<SaveOptions> options, CancellationToken cancellationToken = default)
+    {
+        return CommitAndRefreshChangesAsync(cancellationToken);
+    }
+
+    public Task<int> CommitAsync(Action<SaveOptions> options, CancellationToken cancellationToken = default)
+    {
+        return CommitAsync(cancellationToken);
+    }
+
+    public void ApplyCurrentValues<TEntity>(TEntity original, TEntity current) where TEntity : class, IEntity
+    {
+        ((SetBase<TEntity>)CreateSetCore<TEntity>()).ApplyCurrentValues(original, current);
+    }
+
+    public void Attach<TEntity>(TEntity item) where TEntity : class, IEntity
+    {
+        ((SetBase<TEntity>)CreateSetCore<TEntity>()).Attach(item);
+    }
+
+    public void LoadCollection<TEntity, TElement>(TEntity item,
+        Expression<Func<TEntity, IEnumerable<TElement>>> navigationProperty,
+        Expression<Func<TElement, bool>> filter = null) where TEntity : class where TElement : class
+    {
+        if (filter != null)
+        {
+            Context.Entry<TEntity>(item).Collection(navigationProperty).Query().Where(filter).Load();
+        }
+        else
+        {
+            Context.Entry<TEntity>(item).Collection(navigationProperty).Load();
+        }
+    }
+
+    public async Task LoadCollectionAsync<TEntity, TElement>(TEntity item,
+        Expression<Func<TEntity, IEnumerable<TElement>>> navigationProperty,
+        Expression<Func<TElement, bool>> filter = null) where TEntity : class where TElement : class
+    {
+        if (filter != null)
+        {
+            await Context.Entry<TEntity>(item).Collection(navigationProperty).Query().Where(filter).LoadAsync().ConfigureAwait(false);
+        }
+        else
+        {
+            await Context.Entry<TEntity>(item).Collection(navigationProperty).LoadAsync().ConfigureAwait(false);
+        }
+    }
+
+    public void Reload<TEntity>(TEntity item) where TEntity : class
+    {
+        var entry = Context.Entry(item);
+        entry.CurrentValues.SetValues(entry.OriginalValues);
+        entry.Reload();
+    }
+
+    public void RollbackChanges()
+    {
+        // set all entities in change tracker as 'unchanged state'
+        Context?.ChangeTracker.Entries()
+            .ToList()
+            .ForEach(entry => entry.State = EntityState.Unchanged);
+    }
+
+    public void SetModified<TEntity>(TEntity item) where TEntity : class
+    {
+        // this operation also attaches item in the object state manager
+        Context.Entry<TEntity>(item).State = EntityState.Modified;
+    }
+
+    public virtual SaveOptions GetSaveOptions()
+    {
+        return new SaveOptions();
+    }
+
+    public virtual IRepository<TEntity, TKey> GetRepository<TEntity, TKey>()
+        where TEntity : class, IEntity<TKey>
+    {
+        return ServiceProvider.GetRequiredService<IRepository<TEntity, TKey>>();
+    }
+
+    public IAsyncRepository<TEntity, TKey> GetAsyncRepository<TEntity, TKey>()
+        where TEntity : class, IEntity<TKey>
+    {
+        return ServiceProvider.GetRequiredService<IAsyncRepository<TEntity, TKey>>();
+    }
+
+    public Data.Repository.ISet<TEntity> CreateSet<TEntity>() where TEntity : class, IEntity => CreateSetCore<TEntity>();
+
+    public IQueryableRepository<TEntity, TKey> GetQueryableRepository<TEntity, TKey>()
+        where TEntity : class, IEntity<TKey>
+    {
+        return ServiceProvider.GetRequiredService<IQueryableRepository<TEntity, TKey>>();
+    }
+
+    public IAsyncQueryableRepository<TEntity, TKey> GetAsyncQueryableRepository<TEntity, TKey>()
+        where TEntity : class, IEntity<TKey>
+    {
+        return ServiceProvider.GetRequiredService<IAsyncQueryableRepository<TEntity, TKey>>();
+    }
+
+    internal DbContext GetDbContext() => Context;
+
+    /// <summary>Disposes this instance.</summary>
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>Disposes the managed resources.</summary>
+    /// <param name="disposing">Whether to dispose managed resources.</param>
+    protected virtual void Dispose(bool disposing)
+    {
+        if (Disposed)
+        {
+            return;
+        }
+
+        if (disposing)
+        {
+            Context?.Dispose();
+        }
+
+        Disposed = true;
+    }
+}
+
+/// <summary>
+///     The strongly-typed <see cref="EntityFrameworkUnitOfWork" /> that a document provider's unit of work
+///     derives from over its concrete <typeparamref name="TDbContext" />.
+/// </summary>
+/// <typeparam name="TDbContext">The context type.</typeparam>
+public abstract class EntityFrameworkUnitOfWork<TDbContext>(IServiceProvider serviceProvider, TDbContext context)
+    : EntityFrameworkUnitOfWork(serviceProvider, context)
+    where TDbContext : DbContext;

From 4b2aefde66c41c88f27a02ac0090db33e4c5864c Mon Sep 17 00:00:00 2001
From: Edgar Mesquita <edgar@equantic.tech>
Date: Mon, 20 Jul 2026 19:13:52 +0100
Subject: [PATCH 2/2] =?UTF-8?q?=F0=9F=94=A7=20chore:=20bump=20base=20(4.6.?=
 =?UTF-8?q?0/8.3.0/10.2.0)=20and=20MongoDb=20(8.3.0/10.2.0)=20for=20the=20?=
 =?UTF-8?q?shared=20UnitOfWork?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The base package gained the shared EntityFrameworkUnitOfWork (additive), so it must be republished for the document providers (which now derive from it) to resolve at runtime. MongoDb is bumped to publish its thinned unit of work. The relational providers are unchanged.
---
 .../eQuantic.Core.Data.EntityFramework.MongoDb.Net10.csproj | 6 +++---
 .../eQuantic.Core.Data.EntityFramework.MongoDb.Net8.csproj  | 6 +++---
 .../eQuantic.Core.Data.EntityFramework.Net10.csproj         | 6 +++---
 .../eQuantic.Core.Data.EntityFramework.Net8.csproj          | 6 +++---
 .../eQuantic.Core.Data.EntityFramework.csproj               | 6 +++---
 5 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/eQuantic.Core.Data.EntityFramework.MongoDb/eQuantic.Core.Data.EntityFramework.MongoDb.Net10.csproj b/src/eQuantic.Core.Data.EntityFramework.MongoDb/eQuantic.Core.Data.EntityFramework.MongoDb.Net10.csproj
index 2a64b88..6fb0a41 100644
--- a/src/eQuantic.Core.Data.EntityFramework.MongoDb/eQuantic.Core.Data.EntityFramework.MongoDb.Net10.csproj
+++ b/src/eQuantic.Core.Data.EntityFramework.MongoDb/eQuantic.Core.Data.EntityFramework.MongoDb.Net10.csproj
@@ -4,7 +4,7 @@
     <PropertyGroup>
         <Description>Core Data library for Entity Framework and Mongo DB</Description>
         <AssemblyTitle>eQuantic.Core.Data.EntityFramework.MongoDb</AssemblyTitle>
-        <Version>10.1.0.0</Version>
+        <Version>10.2.0.0</Version>
         <TargetFramework>net10.0</TargetFramework>
         <AssemblyName>eQuantic.Core.Data.EntityFramework.MongoDb</AssemblyName>
         <PackageId>eQuantic.Core.Data.EntityFramework.MongoDb</PackageId>
@@ -12,8 +12,8 @@
         <PackageReleaseNotes>Entity ignorant persistance with Repository Pattern for Entity
             Framework</PackageReleaseNotes>
 
-        <AssemblyVersion>10.1.0.0</AssemblyVersion>
-        <FileVersion>10.1.0.0</FileVersion>
+        <AssemblyVersion>10.2.0.0</AssemblyVersion>
+        <FileVersion>10.2.0.0</FileVersion>
 
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
diff --git a/src/eQuantic.Core.Data.EntityFramework.MongoDb/eQuantic.Core.Data.EntityFramework.MongoDb.Net8.csproj b/src/eQuantic.Core.Data.EntityFramework.MongoDb/eQuantic.Core.Data.EntityFramework.MongoDb.Net8.csproj
index 76c7c37..8f03163 100644
--- a/src/eQuantic.Core.Data.EntityFramework.MongoDb/eQuantic.Core.Data.EntityFramework.MongoDb.Net8.csproj
+++ b/src/eQuantic.Core.Data.EntityFramework.MongoDb/eQuantic.Core.Data.EntityFramework.MongoDb.Net8.csproj
@@ -4,7 +4,7 @@
     <PropertyGroup>
         <Description>Core Data library for Entity Framework and Mongo DB</Description>
         <AssemblyTitle>eQuantic.Core.Data.EntityFramework.MongoDb</AssemblyTitle>
-        <Version>8.2.0.0</Version>
+        <Version>8.3.0.0</Version>
         <TargetFramework>net8.0</TargetFramework>
         <AssemblyName>eQuantic.Core.Data.EntityFramework.MongoDb</AssemblyName>
         <PackageId>eQuantic.Core.Data.EntityFramework.MongoDb</PackageId>
@@ -12,8 +12,8 @@
         <PackageReleaseNotes>Entity ignorant persistance with Repository Pattern for Entity
             Framework</PackageReleaseNotes>
 
-        <AssemblyVersion>8.2.0.0</AssemblyVersion>
-        <FileVersion>8.2.0.0</FileVersion>
+        <AssemblyVersion>8.3.0.0</AssemblyVersion>
+        <FileVersion>8.3.0.0</FileVersion>
 
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
diff --git a/src/eQuantic.Core.Data.EntityFramework/eQuantic.Core.Data.EntityFramework.Net10.csproj b/src/eQuantic.Core.Data.EntityFramework/eQuantic.Core.Data.EntityFramework.Net10.csproj
index ab20736..4c4e58c 100644
--- a/src/eQuantic.Core.Data.EntityFramework/eQuantic.Core.Data.EntityFramework.Net10.csproj
+++ b/src/eQuantic.Core.Data.EntityFramework/eQuantic.Core.Data.EntityFramework.Net10.csproj
@@ -4,7 +4,7 @@
 	<PropertyGroup>
 		<Description>Core Data library for Entity Framework</Description>
 		<AssemblyTitle>eQuantic.Core.Data.EntityFramework</AssemblyTitle>
-		<Version>10.1.0.0</Version>
+		<Version>10.2.0.0</Version>
 		<TargetFramework>net10.0</TargetFramework>
 		<AssemblyName>eQuantic.Core.Data.EntityFramework</AssemblyName>
 		<PackageId>eQuantic.Core.Data.EntityFramework</PackageId>
@@ -12,8 +12,8 @@
 		<PackageReleaseNotes>Entity ignorant persistance with Repository Pattern for Entity
 			Framework</PackageReleaseNotes>
 
-		<AssemblyVersion>10.1.0.0</AssemblyVersion>
-		<FileVersion>10.1.0.0</FileVersion>
+		<AssemblyVersion>10.2.0.0</AssemblyVersion>
+		<FileVersion>10.2.0.0</FileVersion>
 	</PropertyGroup>
 
 	<ItemGroup>
diff --git a/src/eQuantic.Core.Data.EntityFramework/eQuantic.Core.Data.EntityFramework.Net8.csproj b/src/eQuantic.Core.Data.EntityFramework/eQuantic.Core.Data.EntityFramework.Net8.csproj
index ac1500b..d6d78fc 100644
--- a/src/eQuantic.Core.Data.EntityFramework/eQuantic.Core.Data.EntityFramework.Net8.csproj
+++ b/src/eQuantic.Core.Data.EntityFramework/eQuantic.Core.Data.EntityFramework.Net8.csproj
@@ -4,7 +4,7 @@
 	<PropertyGroup>
 		<Description>Core Data library for Entity Framework</Description>
 		<AssemblyTitle>eQuantic.Core.Data.EntityFramework</AssemblyTitle>
-		<Version>8.2.0.0</Version>
+		<Version>8.3.0.0</Version>
 		<TargetFramework>net8.0</TargetFramework>
 		<AssemblyName>eQuantic.Core.Data.EntityFramework</AssemblyName>
 		<PackageId>eQuantic.Core.Data.EntityFramework</PackageId>
@@ -12,8 +12,8 @@
 		<PackageReleaseNotes>Entity ignorant persistance with Repository Pattern for Entity
 			Framework</PackageReleaseNotes>
 
-		<AssemblyVersion>8.2.0.0</AssemblyVersion>
-		<FileVersion>8.2.0.0</FileVersion>
+		<AssemblyVersion>8.3.0.0</AssemblyVersion>
+		<FileVersion>8.3.0.0</FileVersion>
 	</PropertyGroup>
 
 	<ItemGroup>
diff --git a/src/eQuantic.Core.Data.EntityFramework/eQuantic.Core.Data.EntityFramework.csproj b/src/eQuantic.Core.Data.EntityFramework/eQuantic.Core.Data.EntityFramework.csproj
index 776afc9..fe4806a 100644
--- a/src/eQuantic.Core.Data.EntityFramework/eQuantic.Core.Data.EntityFramework.csproj
+++ b/src/eQuantic.Core.Data.EntityFramework/eQuantic.Core.Data.EntityFramework.csproj
@@ -4,15 +4,15 @@
 	<PropertyGroup>
 		<Description>Core Data library for Entity Framework</Description>
 		<AssemblyTitle>eQuantic.Core.Data.EntityFramework</AssemblyTitle>
-		<Version>4.5.0.0</Version>
+		<Version>4.6.0.0</Version>
 		<TargetFrameworks>net8.0;net10.0</TargetFrameworks>
 		<AssemblyName>eQuantic.Core.Data.EntityFramework</AssemblyName>
 		<PackageId>eQuantic.Core.Data.EntityFramework</PackageId>
 		<PackageTags>eQuantic;Core;Data;Library;Repository;Pattern</PackageTags>
 		<PackageReleaseNotes>Entity ignorant persistance with Repository Pattern for Entity Framework</PackageReleaseNotes>
 
-		<AssemblyVersion>4.5.0.0</AssemblyVersion>
-		<FileVersion>4.5.0.0</FileVersion>
+		<AssemblyVersion>4.6.0.0</AssemblyVersion>
+		<FileVersion>4.6.0.0</FileVersion>
 	</PropertyGroup>
 
 	<ItemGroup>