From 5ea1398670334636b0385f97861524f3b388dccd Mon Sep 17 00:00:00 2001
From: cihataydin <cihataydin.tr@gmail.com>
Date: Mon, 19 May 2025 00:55:15 +0300
Subject: [PATCH] refactor(37): enhances repository pattern with additional
 methods and remove unit of work implementation

---
 src/Api/Program.cs                   |   3 +-
 src/Domain/Interfaces/IRepository.cs |  47 ++++++++++--
 src/Domain/Interfaces/IUnitOfWork.cs |   9 ---
 src/Infra/Repositories/Repository.cs | 106 +++++++++++++++++++--------
 src/Infra/Repositories/UnitOfWork.cs |  22 ------
 5 files changed, 116 insertions(+), 71 deletions(-)
 delete mode 100644 src/Domain/Interfaces/IUnitOfWork.cs
 delete mode 100644 src/Infra/Repositories/UnitOfWork.cs

diff --git a/src/Api/Program.cs b/src/Api/Program.cs
index 19eec38..b80aa88 100644
--- a/src/Api/Program.cs
+++ b/src/Api/Program.cs
@@ -19,8 +19,7 @@
 
 builder.Services
     .AddDbContext<DataContext>(opts => opts.UseInMemoryDatabase("DemoDb"))
-    .AddScoped(typeof(IRepository<>), typeof(Repository<>))
-    .AddScoped<IUnitOfWork, UnitOfWork>();
+    .AddScoped(typeof(IRepository<>), typeof(Repository<>));
 
 builder.Services.AddApiVersioning(options =>
    {
diff --git a/src/Domain/Interfaces/IRepository.cs b/src/Domain/Interfaces/IRepository.cs
index 29d76b4..eedf958 100644
--- a/src/Domain/Interfaces/IRepository.cs
+++ b/src/Domain/Interfaces/IRepository.cs
@@ -8,15 +8,50 @@ public interface IRepository<TEntity> : IAsyncDisposable where TEntity : class
 
     Task<TEntity?> GetByIdAsync<TKey>(TKey id, CancellationToken cancellationToken = default);
 
-    Task<List<TEntity>> ListAsync(Expression<Func<TEntity, bool>>? predicate = null, CancellationToken cancellationToken = default);
+    Task<List<TEntity>> ListAsync(Expression<Func<TEntity, bool>>? predicate = null, bool asNoTracking = true, CancellationToken cancellationToken = default);
 
-    Task<TEntity> AddAsync(TEntity entity, CancellationToken cancellationToken = default);
+    Task<bool> AnyAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
 
-    Task UpdateAsync(TEntity entity, CancellationToken cancellationToken = default);
+    Task<int> CountAsync(Expression<Func<TEntity, bool>>? predicate = null, CancellationToken cancellationToken = default);
 
-    Task DeleteAsync(TEntity entity, CancellationToken cancellationToken = default);
+    TEntity Add(TEntity entity);
+    Task<TEntity> AddAsync(
+        TEntity entity,
+        CancellationToken cancellationToken = default);
 
-    Task<int> DeleteAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
+    void AddRange(params TEntity[] entities);
 
-    Task<int> UpdateAsync(Expression<Func<TEntity, bool>> predicate, object updateDefinition, CancellationToken cancellationToken = default);
+    void AddRange(IEnumerable<TEntity> entities);
+
+    Task AddRangeAsync(params TEntity[] entities);
+
+    Task AddRangeAsync(
+        IEnumerable<TEntity> entities,
+        CancellationToken cancellationToken = default);
+
+    TEntity Attach(TEntity entity);
+    void AttachRange(params TEntity[] entities);
+
+    void AttachRange(IEnumerable<TEntity> entities);
+
+    TEntity Update(TEntity entity);
+
+    void UpdateRange(params TEntity[] entities);
+
+    void UpdateRange(IEnumerable<TEntity> entities);
+
+    TEntity Remove(TEntity entity);
+
+    void RemoveRange(params TEntity[] entities);
+
+    void RemoveRange(IEnumerable<TEntity> entities);
+
+    Task<int> ExecuteDeleteAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
+
+    Task<int> ExecuteUpdateAsync(
+    Expression<Func<TEntity, bool>> predicate,
+    object updateDefinition,
+    CancellationToken cancellationToken = default);
+
+    Task<int> SaveChangesAsync(CancellationToken cancellationToken = default);
 }
\ No newline at end of file
diff --git a/src/Domain/Interfaces/IUnitOfWork.cs b/src/Domain/Interfaces/IUnitOfWork.cs
deleted file mode 100644
index 96d8ea8..0000000
--- a/src/Domain/Interfaces/IUnitOfWork.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-namespace Domain.Interfaces;
-
-public interface IUnitOfWork : IAsyncDisposable
-{
-    Task<int> SaveChangesAsync(CancellationToken cancellationToken = default);
-
-    // TODO: implement transaction management
-    // Task<object> BeginTransactionAsync(CancellationToken cancellationToken = default);
-}
\ No newline at end of file
diff --git a/src/Infra/Repositories/Repository.cs b/src/Infra/Repositories/Repository.cs
index bc7bf59..4f82710 100644
--- a/src/Infra/Repositories/Repository.cs
+++ b/src/Infra/Repositories/Repository.cs
@@ -6,7 +6,7 @@
 
 namespace Infra.Repositories;
 
-public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
+public class Repository<TEntity> : IRepository<TEntity> where TEntity : class, new()
 {
     private readonly DataContext _dataContext;
     private readonly DbSet<TEntity> _dbSet;
@@ -18,61 +18,103 @@ public Repository(DataContext dataContext)
         _dbSet = dataContext.Set<TEntity>();
     }
 
-    public IQueryable<TEntity> Query(bool asNoTracking = true) => (asNoTracking ? _dbSet.AsNoTracking() : _dbSet).AsQueryable();
+    public IQueryable<TEntity> Query(bool asNoTracking = true) =>
+        asNoTracking ? _dbSet.AsNoTracking() : _dbSet.AsQueryable();
 
     public Task<TEntity?> GetByIdAsync<TKey>(TKey id, CancellationToken cancellationToken = default)
-    {
-        return _dbSet.FindAsync(new object?[] { id }!, cancellationToken).AsTask();
-    }
+        => _dbSet.FindAsync(new object?[] { id }!, cancellationToken).AsTask();
 
-    public Task<List<TEntity>> ListAsync(Expression<Func<TEntity, bool>>? predicate = null, CancellationToken cancellationToken = default)
+    public Task<List<TEntity>> ListAsync(
+        Expression<Func<TEntity, bool>>? predicate = null,
+        bool asNoTracking = true,
+        CancellationToken cancellationToken = default)
     {
-        IQueryable<TEntity> query = _dbSet;
-        if (predicate is not null) query = query.Where(predicate);
+        IQueryable<TEntity> query = Query(asNoTracking);
+        if (predicate != null) query = query.Where(predicate);
         return query.ToListAsync(cancellationToken);
     }
 
-    public async Task<TEntity> AddAsync(TEntity entity, CancellationToken cancellationToken = default)
-    {
-        await _dbSet.AddAsync(entity, cancellationToken);
+    public Task<bool> AnyAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
+        => _dbSet.AnyAsync(predicate, cancellationToken);
 
-        return entity;
-    }
+    public Task<int> CountAsync(Expression<Func<TEntity, bool>>? predicate = null, CancellationToken cancellationToken = default)
+        => predicate == null
+            ? _dbSet.CountAsync(cancellationToken)
+            : _dbSet.CountAsync(predicate, cancellationToken);
 
-    public Task UpdateAsync(TEntity entity, CancellationToken cancellationToken = default)
-    {
-        _dbSet.Update(entity);
+    public TEntity Add(TEntity entity)
+        => _dbSet.Add(entity).Entity;
 
-        return Task.CompletedTask;
-    }
+    public async Task<TEntity> AddAsync(
+        TEntity entity,
+        CancellationToken cancellationToken = default)
+        => (await _dbSet.AddAsync(entity, cancellationToken)).Entity;
 
-    public Task DeleteAsync(TEntity entity, CancellationToken cancellationToken = default)
-    {
-        _dbSet.Remove(entity);
+    public void AddRange(params TEntity[] entities)
+        => _dbSet.AddRange(entities);
 
-        return Task.CompletedTask;
-    }
+    public void AddRange(IEnumerable<TEntity> entities)
+        => _dbSet.AddRange(entities);
 
-    public Task<int> DeleteAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
-    {
-        return _dbSet.Where(predicate).ExecuteDeleteAsync(cancellationToken);
-    }
+    public Task AddRangeAsync(params TEntity[] entities)
+        => _dbSet.AddRangeAsync(entities);
+
+    public Task AddRangeAsync(
+        IEnumerable<TEntity> entities,
+        CancellationToken cancellationToken = default)
+        => _dbSet.AddRangeAsync(entities, cancellationToken);
 
-    public Task<int> UpdateAsync(Expression<Func<TEntity, bool>> predicate, object updateDefinition, CancellationToken cancellationToken = default)
+    public TEntity Attach(TEntity entity)
+        => _dbSet.Attach(entity).Entity;
+
+    public void AttachRange(params TEntity[] entities)
+        => _dbSet.AttachRange(entities);
+
+    public void AttachRange(IEnumerable<TEntity> entities)
+        => _dbSet.AttachRange(entities);
+
+    public TEntity Update(TEntity entity)
+        => _dbSet.Update(entity).Entity;
+
+    public void UpdateRange(params TEntity[] entities)
+        => _dbSet.UpdateRange(entities);
+
+    public void UpdateRange(IEnumerable<TEntity> entities)
+        => _dbSet.UpdateRange(entities);
+
+    public TEntity Remove(TEntity entity)
+        => _dbSet.Remove(entity).Entity;
+
+    public void RemoveRange(params TEntity[] entities)
+        => _dbSet.RemoveRange(entities);
+
+    public void RemoveRange(IEnumerable<TEntity> entities)
+        => _dbSet.RemoveRange(entities);
+
+    public Task<int> ExecuteDeleteAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
+        => _dbSet.Where(predicate).ExecuteDeleteAsync(cancellationToken);
+
+    public Task<int> ExecuteUpdateAsync(
+        Expression<Func<TEntity, bool>> predicate,
+        object updateDefinition,
+        CancellationToken cancellationToken = default)
     {
-        if (updateDefinition is not Expression<Func<SetPropertyCalls<TEntity>, SetPropertyCalls<TEntity>>> expression)
+        if (updateDefinition is not Expression<Func<SetPropertyCalls<TEntity>, SetPropertyCalls<TEntity>>> updateExpression)
         {
-            throw new InvalidOperationException($"Invalid update definition for type '{typeof(TEntity).Name}'. Expected an expression of type Expression<Func<SetPropertyCalls<{typeof(TEntity).Name}>, SetPropertyCalls<{typeof(TEntity).Name}>>>.");
+            throw new ArgumentException("Invalid update expression for EF Core", nameof(updateDefinition));
         }
 
-        return _dbSet.Where(predicate).ExecuteUpdateAsync(expression, cancellationToken);
+        return _dbSet.Where(predicate).ExecuteUpdateAsync(updateExpression, cancellationToken);
     }
 
+    public Task<int> SaveChangesAsync(CancellationToken cancellationToken = default) => _dataContext.SaveChangesAsync(cancellationToken);
+
     public async ValueTask DisposeAsync()
     {
         if (Interlocked.Exchange(ref _disposed, 1) == 0)
         {
             await _dataContext.DisposeAsync();
+            GC.SuppressFinalize(this);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Infra/Repositories/UnitOfWork.cs b/src/Infra/Repositories/UnitOfWork.cs
deleted file mode 100644
index e422049..0000000
--- a/src/Infra/Repositories/UnitOfWork.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using Infra.Data;
-using Domain.Interfaces;
-
-namespace Infra.Repositories;
-
-public class UnitOfWork : IUnitOfWork
-{
-    private readonly DataContext _dataContext;
-    private int _disposed;
-
-    public UnitOfWork(DataContext dataContext) => _dataContext = dataContext;
-
-    public Task<int> SaveChangesAsync(CancellationToken cancellationToken = default) => _dataContext.SaveChangesAsync(cancellationToken);
-
-    public async ValueTask DisposeAsync()
-    {
-        if (Interlocked.Exchange(ref _disposed, 1) == 0)
-        {
-            await _dataContext.DisposeAsync();
-        }
-    }
-}
\ No newline at end of file