From d16a4b6bb427137f114c207ed0e258622e8c0a77 Mon Sep 17 00:00:00 2001
From: TekH <h.tek@digitaldata.works>
Date: Wed, 5 Nov 2025 14:20:12 +0100
Subject: [PATCH] refactor(repository): make UpdateAsync more flexible with
 Action<TEntity>

- Introduced Action<TEntity>-based UpdateAsync method for more flexible updates
- Updated TDto-based UpdateAsync to delegate to the new method
- Reduced code duplication and Mapper dependency
- Preserved existing Create, Read, and Delete functionality
---
 .../Repository/IRepository.cs                 |  71 +++++----
 .../DbRepository.cs                           | 149 +++++++++---------
 2 files changed, 116 insertions(+), 104 deletions(-)

diff --git a/DigitalData.Core.Abstraction.Application/Repository/IRepository.cs b/DigitalData.Core.Abstraction.Application/Repository/IRepository.cs
index 27dd627..5433e71 100644
--- a/DigitalData.Core.Abstraction.Application/Repository/IRepository.cs
+++ b/DigitalData.Core.Abstraction.Application/Repository/IRepository.cs
@@ -1,5 +1,4 @@
-using DigitalData.Core.Abstractions.Interfaces;
-using System.Linq.Expressions;
+using System.Linq.Expressions;
 #if NETFRAMEWORK
 using System;
 using System.Collections.Generic;
@@ -15,90 +14,100 @@ namespace DigitalData.Core.Abstraction.Application.Repository
     {
 #endif
 
-public interface IRepository<TEntity>
-{
-    #region Create
+    public interface IRepository<TEntity>
+    {
+        #region Create
+#if NET
+    public
+#endif
+        Task<TEntity> CreateAsync(TEntity entity, CancellationToken cancel = default);
+
 #if NET
     public
 #endif
-    Task<TEntity> CreateAsync(TEntity entity, CancellationToken cancel = default);
+        Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken cancel = default);
 
 #if NET
     public
 #endif
-    Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken cancel = default);
+        Task<TEntity> CreateAsync<TDto>(TDto dto, CancellationToken cancel = default);
 
 #if NET
     public
 #endif
-    Task<TEntity> CreateAsync<TDto>(TDto dto, CancellationToken cancel = default);
+        Task<IEnumerable<TEntity>> CreateAsync<TDto>(IEnumerable<TDto> dtos, CancellationToken cancel = default);
+        #endregion Create
 
+        #region Read
 #if NET
     public
 #endif
-    Task<IEnumerable<TEntity>> CreateAsync<TDto>(IEnumerable<TDto> dtos, CancellationToken cancel = default);
-    #endregion Create
+        IQueryable<TEntity> Query { get; }
 
-    #region Read
 #if NET
     public
 #endif
-    IQueryable<TEntity> Query { get; }
+        IQueryable<TEntity> Where(Expression<Func<TEntity, bool>> expression);
 
 #if NET
     public
 #endif
-    IQueryable<TEntity> Where(Expression<Func<TEntity, bool>> expression);
+        IEnumerable<TEntity> GetAll();
 
 #if NET
     public
 #endif
-    IEnumerable<TEntity> GetAll();
+        Task<IEnumerable<TEntity>> GetAllAsync(CancellationToken cancel = default);
+        #endregion Read
 
+        #region Update
 #if NET
     public
 #endif
-    Task<IEnumerable<TEntity>> GetAllAsync(CancellationToken cancel = default);
-    #endregion Read
+        Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
 
-    #region Update
 #if NET
     public
 #endif
-    Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
+        Task UpdateAsync<TDto>(TDto dto, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default);
 
 #if NET
     public
 #endif
-    Task UpdateAsync<TDto>(TDto dto, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default);
-    #endregion Update
+        Task UpdateAsync(Action<TEntity> modification, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default);
 
-    #region Delete
 #if NET
     public
 #endif
-    Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
+        Task UpdateAsync(Action<TEntity> modification, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
+        #endregion Update
 
+        #region Delete
 #if NET
     public
 #endif
-    Task DeleteAsync(Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default);
-    #endregion Delete
+        Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
 
-    #region Obsolete
-    [Obsolete("Use CreateAsync, UpdateAsync or DeleteAsync")]
 #if NET
     public
 #endif
-    IQueryable<TEntity> Read();
+        Task DeleteAsync(Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default);
+        #endregion Delete
 
-    [Obsolete("Use IRepository<TEntity>.Where")]
+        #region Obsolete
+        [Obsolete("Use CreateAsync, UpdateAsync or DeleteAsync")]
 #if NET
     public
 #endif
-    IQueryable<TEntity> ReadOnly();
-    #endregion
-}
+        IQueryable<TEntity> Read();
+
+        [Obsolete("Use IRepository<TEntity>.Where")]
+#if NET
+    public
+#endif
+        IQueryable<TEntity> ReadOnly();
+        #endregion
+    }
 #if NETFRAMEWORK
     }
 #endif
\ No newline at end of file
diff --git a/DigitalData.Core.Infrastructure/DbRepository.cs b/DigitalData.Core.Infrastructure/DbRepository.cs
index fde9865..a0a2f42 100644
--- a/DigitalData.Core.Infrastructure/DbRepository.cs
+++ b/DigitalData.Core.Infrastructure/DbRepository.cs
@@ -21,114 +21,117 @@ namespace DigitalData.Core.Infrastructure
     {
 #endif
 
-public class DbRepository<TDbContext, TEntity> : IRepository<TEntity> where TDbContext : DbContext where TEntity : class
-{
-    protected internal readonly TDbContext Context;
+    public class DbRepository<TDbContext, TEntity> : IRepository<TEntity> where TDbContext : DbContext where TEntity : class
+    {
+        protected internal readonly TDbContext Context;
 
-    protected internal readonly DbSet<TEntity> Entities;
+        protected internal readonly DbSet<TEntity> Entities;
 
-    public IMapper
+        public IMapper
 #if NET
         ?
 #endif
-        Mapper { get; }
+            Mapper { get; }
 
-    public DbRepository(TDbContext context, DbSetFactory<TDbContext, TEntity> factory, IMapper
+        public DbRepository(TDbContext context, DbSetFactory<TDbContext, TEntity> factory, IMapper
 #if NET
         ?
 #endif
-        mapper = null)
-    {
-        Context = context;
-        Entities = factory.Create(context);
-        Mapper = mapper;
-    }
+            mapper = null)
+        {
+            Context = context;
+            Entities = factory.Create(context);
+            Mapper = mapper;
+        }
 
-    #region Create
-    public virtual async Task<TEntity> CreateAsync(TEntity entity, CancellationToken cancel = default)
-    {
-        Entities.Add(entity);
-        await Context.SaveChangesAsync(cancel);
-        return entity;
-    }
+        #region Create
+        public virtual async Task<TEntity> CreateAsync(TEntity entity, CancellationToken cancel = default)
+        {
+            Entities.Add(entity);
+            await Context.SaveChangesAsync(cancel);
+            return entity;
+        }
 
-    public virtual async Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken cancel = default)
-    {
-        Entities.AddRange(entities);
-        await Context.SaveChangesAsync(cancel);
-        return entities;
-    }
+        public virtual async Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken cancel = default)
+        {
+            Entities.AddRange(entities);
+            await Context.SaveChangesAsync(cancel);
+            return entities;
+        }
 
-    public virtual Task<TEntity> CreateAsync<TDto>(TDto dto, CancellationToken cancel = default)
-        => CreateAsync(Mapper
+        public virtual Task<TEntity> CreateAsync<TDto>(TDto dto, CancellationToken cancel = default)
+            => CreateAsync(Mapper
 #if NET
             !
 #endif
-            .Map<TEntity>(dto), cancel);
+                .Map<TEntity>(dto), cancel);
 
-    public virtual Task<IEnumerable<TEntity>> CreateAsync<TDto>(IEnumerable<TDto> dtos, CancellationToken cancel = default) 
-        => CreateAsync(Mapper
+        public virtual Task<IEnumerable<TEntity>> CreateAsync<TDto>(IEnumerable<TDto> dtos, CancellationToken cancel = default)
+            => CreateAsync(Mapper
 #if NET
             !
 #endif
-            .Map<IEnumerable<TEntity>>(dtos), cancel);
-    #endregion Create
-
-    #region Read
-    public virtual IQueryable<TEntity> Query => Entities.AsNoTracking();
+                .Map<IEnumerable<TEntity>>(dtos), cancel);
+        #endregion Create
 
-    public virtual IQueryable<TEntity> Where(Expression<Func<TEntity, bool>> expression) => Entities.AsNoTracking().Where(expression);
+        #region Read
+        public virtual IQueryable<TEntity> Query => Entities.AsNoTracking();
 
-    public virtual IEnumerable<TEntity> GetAll() => Entities.AsNoTracking().ToList();
+        public virtual IQueryable<TEntity> Where(Expression<Func<TEntity, bool>> expression) => Entities.AsNoTracking().Where(expression);
 
-    public virtual async Task<IEnumerable<TEntity>> GetAllAsync(CancellationToken cancel = default) => await Entities.AsNoTracking().ToListAsync(cancel);
-    #endregion Read
+        public virtual IEnumerable<TEntity> GetAll() => Entities.AsNoTracking().ToList();
 
-    #region Update
-    public virtual Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default) => UpdateAsync(dto, q => q.Where(expression), cancel);
+        public virtual async Task<IEnumerable<TEntity>> GetAllAsync(CancellationToken cancel = default) => await Entities.AsNoTracking().ToListAsync(cancel);
+        #endregion Read
 
-    public virtual async Task UpdateAsync<TDto>(TDto dto, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
-    {
-        var entities = await query(Entities).ToListAsync(cancel);
+        #region Update
+        public virtual Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default) => UpdateAsync(dto, q => q.Where(expression), cancel);
 
-        for (int i = entities.Count - 1; i >= 0; i--)
-        {
-            Mapper
+        public virtual Task UpdateAsync<TDto>(TDto dto, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
+            => UpdateAsync(entity => Mapper
 #if NET
-                !
+                                            !
 #endif
-                .Map(dto, entities[i]);
-            Entities.Update(entities[i]);
-        }
+                                            .Map(dto, entity), query, cancel);
 
-        await Context.SaveChangesAsync(cancel);
-    }
-    #endregion Update
+        public virtual async Task UpdateAsync(Action<TEntity> modification, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
+        {
+            var entities = await query(Entities).ToListAsync(cancel);
 
-    #region Delete
-    public virtual Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default) => DeleteAsync(q => q.Where(expression), cancel);
+            for (int i = entities.Count - 1; i >= 0; i--)
+                modification.Invoke(entities[i]);
 
-    public virtual async Task DeleteAsync(Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
-    {
-        var entities = await query(Entities).ToListAsync(cancel);
+            await Context.SaveChangesAsync(cancel);
+        }
 
-        for (int i = entities.Count - 1; i >= 0; i--)
+        public virtual Task UpdateAsync(Action<TEntity> modification, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default)
+            => UpdateAsync(modification, q => q.Where(expression), cancel);
+        #endregion Update
+
+        #region Delete
+        public virtual Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default) => DeleteAsync(q => q.Where(expression), cancel);
+
+        public virtual async Task DeleteAsync(Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
         {
-            Entities.Remove(entities[i]);
-        }
+            var entities = await query(Entities).ToListAsync(cancel);
 
-        await Context.SaveChangesAsync(cancel);
-    }
-    #endregion Delete
+            for (int i = entities.Count - 1; i >= 0; i--)
+            {
+                Entities.Remove(entities[i]);
+            }
 
-    #region Obsolete
-    [Obsolete("Use IRepository<TEntity>.Where")]
-    public virtual IQueryable<TEntity> Read() => Entities.AsQueryable();
+            await Context.SaveChangesAsync(cancel);
+        }
+        #endregion Delete
+
+        #region Obsolete
+        [Obsolete("Use IRepository<TEntity>.Where")]
+        public virtual IQueryable<TEntity> Read() => Entities.AsQueryable();
 
-    [Obsolete("Use IRepository<TEntity>.Get")]
-    public virtual IQueryable<TEntity> ReadOnly() => Entities.AsNoTracking();
-    #endregion
-}
+        [Obsolete("Use IRepository<TEntity>.Get")]
+        public virtual IQueryable<TEntity> ReadOnly() => Entities.AsNoTracking();
+        #endregion
+    }
 #if NETFRAMEWORK
     }
 #endif
\ No newline at end of file