Add logging support to UnitOfWork and ReadonlyUnitOfWork classes

Integrated `ILogger` to `UnitOfWork` and `ReadonlyUnitOfWork` for improved error handling and debugging. Updated related factories and tests accordingly.

Author: AnnaSasDev

src/CodeOfChaos.Extensions.EntityFrameworkCore/UnitOfWork/ReadonlyUnitOfWork.cs

@@ -2,15 +2,17 @@
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 
 namespace Microsoft.EntityFrameworkCore;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
 public class ReadonlyUnitOfWork<TDbContext>(
     IDbContextFactory<TDbContext> dbContextFactory,
-    AsyncServiceScope serviceScope
-) : UnitOfWork<TDbContext>(dbContextFactory, serviceScope), IReadonlyUnitOfWork<TDbContext>
+    AsyncServiceScope serviceScope,
+    ILogger<ReadonlyUnitOfWork<TDbContext>> logger
+) : UnitOfWork<TDbContext>(dbContextFactory, serviceScope, logger), IReadonlyUnitOfWork<TDbContext>
     where TDbContext : DbContext, IReadonlyCapableDbContext {
 
     public async override ValueTask<TDbContext> GetDbContextAsync(CancellationToken ct) {

src/CodeOfChaos.Extensions.EntityFrameworkCore/UnitOfWork/ReadonlyUnitOfWorkFactory.cs

@@ -2,6 +2,7 @@
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 
 namespace Microsoft.EntityFrameworkCore;
 
@@ -10,11 +11,12 @@ namespace Microsoft.EntityFrameworkCore;
 // ---------------------------------------------------------------------------------------------------------------------
 public class ReadonlyUnitOfWorkFactory<TDbContext>(
     IDbContextFactory<TDbContext> dbContextFactory,
-    IServiceProvider provider
+    IServiceProvider provider,
+    ILoggerFactory loggerFactory
 ) : IReadonlyUnitOfWorkFactory<TDbContext> where TDbContext : DbContext, IReadonlyCapableDbContext {
 
     public IReadonlyUnitOfWork<TDbContext> Create() {
         AsyncServiceScope scope = provider.CreateAsyncScope();
-        return new ReadonlyUnitOfWork<TDbContext>(dbContextFactory, scope);
+        return new ReadonlyUnitOfWork<TDbContext>(dbContextFactory, scope, loggerFactory.CreateLogger<ReadonlyUnitOfWork<TDbContext>>());
     }
 }

src/CodeOfChaos.Extensions.EntityFrameworkCore/UnitOfWork/UnitOfWork.cs

@@ -3,28 +3,29 @@
 // ---------------------------------------------------------------------------------------------------------------------
 using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using System.Collections.Concurrent;
 using System.Runtime.CompilerServices;
 
 namespace Microsoft.EntityFrameworkCore;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-public class UnitOfWork<TDbContext>(IDbContextFactory<TDbContext> dbContextFactory, AsyncServiceScope serviceScope) : IUnitOfWork<TDbContext> where TDbContext : DbContext {
+public class UnitOfWork<TDbContext>(IDbContextFactory<TDbContext> dbContextFactory, AsyncServiceScope serviceScope, ILogger<UnitOfWork<TDbContext>> logger) : IUnitOfWork<TDbContext> where TDbContext : DbContext {
     private TDbContext? _dbContext;
     private IDbContextTransaction? _transaction;
     private readonly ConcurrentDictionary<Type, IUnitOfWorkRepository> AttachedRepositories = [];
     private readonly SemaphoreSlim _initLockAsync = new(1, 1);
     private readonly SemaphoreSlim _transactionLockAsync = new(1, 1);
     private readonly Lock _transactionLock = new();
     private readonly Lazy<TDbContext> _lazyDb = new(dbContextFactory.CreateDbContext, LazyThreadSafetyMode.ExecutionAndPublication);
-    
+
     internal bool IsDisposed { get; private set; }
-    
+
     // -----------------------------------------------------------------------------------------------------------------
     // Methods
     // -----------------------------------------------------------------------------------------------------------------
-    public virtual async ValueTask<TDbContext> GetDbContextAsync(CancellationToken ct) {
+    public async virtual ValueTask<TDbContext> GetDbContextAsync(CancellationToken ct) {
         if (_dbContext != null) return _dbContext;
 
         await _initLockAsync.WaitAsync(ct);
@@ -44,7 +45,7 @@ public virtual async ValueTask<TDbContext> GetDbContextAsync(CancellationToken c
 
     public virtual bool TryCreateTransaction() {
         if (_transaction != null) return false;
-        
+
         var dbContext = GetDbContext<TDbContext>();
         if (dbContext.Database.CurrentTransaction != null) {
             _transaction = dbContext.Database.CurrentTransaction;
@@ -56,8 +57,8 @@ public virtual bool TryCreateTransaction() {
             return true;
         }
     }
-    
-    public virtual async ValueTask<bool> TryCreateTransactionAsync(CancellationToken ct = default) {
+
+    public async virtual ValueTask<bool> TryCreateTransactionAsync(CancellationToken ct = default) {
         if (_transaction != null) return false;
 
         TDbContext dbContext = await GetDbContextAsync(ct);
@@ -71,6 +72,11 @@ public virtual async ValueTask<bool> TryCreateTransactionAsync(CancellationToken
             _transaction = await dbContext.Database.BeginTransactionAsync(ct);
             return true;
         }
+        catch (Exception ex) {
+            logger.LogError(ex, "Failed to begin transaction.");
+            _transaction = null;
+            return false;
+        }
         finally {
             _transactionLockAsync.Release();
         }
@@ -80,24 +86,33 @@ public virtual void SaveChanges() {
         DbContext dbContext = GetDbContext<TDbContext>();
         dbContext.SaveChanges();
     }
-    
-    public virtual async ValueTask SaveChangesAsync(CancellationToken ct = default) {
+
+    public async virtual ValueTask SaveChangesAsync(CancellationToken ct = default) {
         DbContext dbContext = await GetDbContextAsync(ct);
         await dbContext.SaveChangesAsync(ct);
     }
-    
+
     public virtual bool TryCommitTransaction() {
         if (_transaction == null) return false;
 
         lock (_transactionLock) {
-            _transaction.Commit();
-            _transaction.Dispose();
-            _transaction = null;
-            return true;
+            try {
+                _transaction.Commit();
+                _transaction.Dispose();
+                _transaction = null;
+                return true;
+            }
+            catch (Exception ex) {
+                logger.LogError(ex, "Failed to commit transaction.");
+                lock (_transactionLock) {
+                    _transaction = null;
+                }
+                return false;
+            }
         }
     }
 
-    public virtual async ValueTask<bool> TryCommitTransactionAsync(CancellationToken ct = default) {
+    public async virtual ValueTask<bool> TryCommitTransactionAsync(CancellationToken ct = default) {
         if (_transaction == null) return false;
 
         await _transactionLockAsync.WaitAsync(ct);
@@ -107,103 +122,162 @@ public virtual async ValueTask<bool> TryCommitTransactionAsync(CancellationToken
             _transaction = null;
             return true;
         }
+        catch (Exception ex) {
+            logger.LogError(ex, "Failed to commit transaction.");
+            _transaction = null;
+            return false;
+        }
         finally {
             _transactionLockAsync.Release();
         }
     }
 
     public virtual bool TryRollbackTransaction() {
         if (_transaction == null) return false;
-        
-        _transaction.Rollback();
-        _transaction.Dispose();
-        _transaction = null;
-        
-        return true;
+
+        lock (_transactionLock) {
+            try {
+                _transaction.Rollback();
+                _transaction.Dispose();
+                _transaction = null;
+                return true;
+            }
+            catch (Exception ex) {
+                logger.LogError(ex, "Failed to rollback transaction.");
+                lock (_transactionLock) {
+                    _transaction = null;
+                }
+                return false;
+            }
+        }
     }
 
-    public virtual async ValueTask<bool> TryRollbackTransactionAsync(CancellationToken ct = default) {
+    public async virtual ValueTask<bool> TryRollbackTransactionAsync(CancellationToken ct = default) {
         if (_transaction == null) return false;
 
-        await _transaction.RollbackAsync(ct);
-        await _transaction.DisposeAsync();
-        _transaction = null;
-
-        return true;
+        await _transactionLockAsync.WaitAsync(ct);
+        try {
+            await _transaction.RollbackAsync(ct);
+            await _transaction.DisposeAsync();
+            _transaction = null;
+            return true;
+        }
+        catch (Exception ex) {
+            logger.LogError(ex, "Failed to rollback transaction.");
+            _transaction = null;
+            return false;
+        }
+        finally {
+            _transactionLockAsync.Release();
+        }
     }
 
     public virtual bool TryRollbackToSavepoint(Guid id) {
         if (_transaction == null) return false;
         if (!_transaction.SupportsSavepoints) return false;
-        
-        _transaction.RollbackToSavepoint(id.ToString("N"));
-        return true;
+
+        lock (_transactionLock) {
+            try {
+                _transaction.RollbackToSavepoint(id.ToString("N"));
+                return true;
+            }
+            catch (Exception ex) {
+                logger.LogError(ex, "Failed to rollback to savepoint.");
+                return false;
+            }
+        }
     }
 
-    public virtual async ValueTask<bool> TryRollbackToSavepointAsync(Guid id, CancellationToken ct = default) {
+    public async virtual ValueTask<bool> TryRollbackToSavepointAsync(Guid id, CancellationToken ct = default) {
         if (_transaction == null) return false;
         if (!_transaction.SupportsSavepoints) return false;
 
-        await _transaction.RollbackToSavepointAsync(id.ToString("N"), ct);
-
-        return true;
+        await _transactionLockAsync.WaitAsync(ct);
+        try {
+            await _transaction.RollbackToSavepointAsync(id.ToString("N"), ct);
+            return true;
+        }
+        catch (Exception ex) {
+            logger.LogError(ex, "Failed to rollback to savepoint.");
+            return false;
+        }
+        finally {
+            _transactionLockAsync.Release();
+        }
     }
-    
+
     public virtual bool TryCreateSavepoint(Guid id) {
         if (_transaction == null) return false;
         if (!_transaction.SupportsSavepoints) return false;
-        
-        _transaction.CreateSavepoint(id.ToString("N"));
-        return true;
+
+        lock (_transactionLock) {
+            try {
+                _transaction.CreateSavepoint(id.ToString("N"));
+                return true;
+            }
+            catch (Exception ex) {
+                logger.LogError(ex, "Failed to create savepoint.");
+                return false;
+            }
+        }
     }
 
-    public virtual async ValueTask<bool> TryCreateSavepointAsync(Guid id, CancellationToken ct = default) {
+    public async virtual ValueTask<bool> TryCreateSavepointAsync(Guid id, CancellationToken ct = default) {
         if (_transaction == null) return false;
         if (!_transaction.SupportsSavepoints) return false;
 
-        await _transaction.CreateSavepointAsync(id.ToString("N"), ct);
-
-        return true;
+        await _transactionLockAsync.WaitAsync(ct);
+        try {
+            await _transaction.CreateSavepointAsync(id.ToString("N"), ct);
+            return true;
+        }
+        catch (Exception ex) {
+            logger.LogError(ex, "Failed to create savepoint.");
+            return false;
+        }
+        finally {
+            _transactionLockAsync.Release();
+        }
     }
-    
+
     public virtual T GetDbContext<T>() where T : DbContext {
         if (typeof(T) != typeof(TDbContext)) throw new NotSupportedException($"DbContext type '{typeof(T)}' is not supported by this UnitOfWork.");
-        
+
         TDbContext dbContext = GetDbContext();
-        
+
         return Unsafe.As<TDbContext, T>(ref dbContext);
     }
 
-    public virtual async ValueTask<T> GetDbContextAsync<T>(CancellationToken ct = default) where T : DbContext {
+    public async virtual ValueTask<T> GetDbContextAsync<T>(CancellationToken ct = default) where T : DbContext {
         if (typeof(T) != typeof(TDbContext)) throw new NotSupportedException($"DbContext type '{typeof(T)}' is not supported by this UnitOfWork.");
 
         TDbContext dbContext = await GetDbContextAsync(ct);
-        
+
         return Unsafe.As<TDbContext, T>(ref dbContext);
     }
 
     public virtual TRepo GetRepository<TRepo>() where TRepo : class, IUnitOfWorkRepository {
         if (AttachedRepositories.TryGetValue(typeof(TRepo), out IUnitOfWorkRepository? cachedRepo) && cachedRepo is TRepo castedCachedRepo) return castedCachedRepo;
-        
+
         var repo = CreateAndAttachRepository<TRepo>();
-        
+
         AttachedRepositories.AddOrUpdate(
             typeof(TRepo),
-            repo, 
+            repo,
             (_, _) => repo
         );
         return repo;
     }
 
-    public virtual async ValueTask<TRepo> GetRepositoryAsync<TRepo>(CancellationToken ct = default) where TRepo : class, IUnitOfWorkRepository {
+    public async virtual ValueTask<TRepo> GetRepositoryAsync<TRepo>(CancellationToken ct = default) where TRepo : class, IUnitOfWorkRepository {
         if (AttachedRepositories.TryGetValue(typeof(TRepo), out IUnitOfWorkRepository? cachedRepo) && cachedRepo is TRepo castedCachedRepo) return castedCachedRepo;
 
         // Cache miss so we create a new instance
         var repo = await CreateAndAttachRepositoryAsync<TRepo>(ct);
 
         AttachedRepositories.AddOrUpdate(
             typeof(TRepo),
-            repo, 
+            repo,
             (_, _) => repo
         );
         return repo;
@@ -212,11 +286,11 @@ public virtual async ValueTask<TRepo> GetRepositoryAsync<TRepo>(CancellationToke
     private TRepo CreateAndAttachRepository<TRepo>() where TRepo : class, IUnitOfWorkRepository {
         var repo = serviceScope.ServiceProvider.GetRequiredService<TRepo>();
         if (repo is not UnitOfWorkRepository<TDbContext> castedRepo) throw new InvalidCastException($"Cannot cast repository of type '{repo.GetType()}' to '{typeof(TRepo)}'");
-        
+
         castedRepo.Attach(this);
         return repo;
     }
-    
+
     private async ValueTask<TRepo> CreateAndAttachRepositoryAsync<TRepo>(CancellationToken ct = default) where TRepo : class, IUnitOfWorkRepository {
         var repo = serviceScope.ServiceProvider.GetRequiredService<TRepo>();
         if (repo is not UnitOfWorkRepository<TDbContext> castedRepo) throw new InvalidCastException($"Cannot cast repository of type '{repo.GetType()}' to '{typeof(TRepo)}'");
@@ -225,7 +299,7 @@ private async ValueTask<TRepo> CreateAndAttachRepositoryAsync<TRepo>(Cancellatio
         return repo;
     }
 
-    public virtual async ValueTask DisposeAsync() {
+    public async virtual ValueTask DisposeAsync() {
         // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
         if (_initLockAsync == null) {
             GC.SuppressFinalize(this);

src/CodeOfChaos.Extensions.EntityFrameworkCore/UnitOfWork/UnitOfWorkFactory.cs

@@ -9,14 +9,14 @@ namespace Microsoft.EntityFrameworkCore;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-public class UnitOfWorkFactory<TDbContext>(IDbContextFactory<TDbContext> dbContextFactory, IServiceProvider provider, ILogger<UnitOfWorkFactory<TDbContext>> logger) : IUnitOfWorkFactory<TDbContext> where TDbContext : DbContext {
+public class UnitOfWorkFactory<TDbContext>(IDbContextFactory<TDbContext> dbContextFactory, IServiceProvider provider, ILogger<UnitOfWorkFactory<TDbContext>> logger, ILoggerFactory loggerFactory) : IUnitOfWorkFactory<TDbContext> where TDbContext : DbContext {
     public IUnitOfWork<TDbContext> Create() {
         // Each unit of work should have their own scope which they pull their repositories from
         //      This, if the factory is used correctly, should enforce correct usage and limit dbcontext concurrency issues.
         AsyncServiceScope scope = provider.CreateAsyncScope();
 
         // Because our factory doesn't create the actual dbcontext, yet we are safe, and we can just inject it downwards.
-        return new UnitOfWork<TDbContext>(dbContextFactory, scope);
+        return new UnitOfWork<TDbContext>(dbContextFactory, scope, loggerFactory.CreateLogger<UnitOfWork<TDbContext>>());
     }
 
     public IUnitOfWork<TDbContext> CreateWithTransaction() {