Add readonly transaction management to ReadonlyUnitOfWork

Author: AnnaSasDev

src/CodeOfChaos.Types.UnitOfWork.Contracts/IUnitOfWork.cs

@@ -23,12 +23,12 @@ public interface IUnitOfWork : IAsyncDisposable {
     bool TryRollbackTransaction();
     ValueTask<bool> TryRollbackTransactionAsync(CancellationToken ct = default);
 
+    bool TryCreateSavepoint(Guid id);
+    ValueTask<bool> TryCreateSavepointAsync(Guid id, CancellationToken ct = default);
+    
     bool TryRollbackToSavepoint(Guid id);
     ValueTask<bool> TryRollbackToSavepointAsync(Guid id, CancellationToken ct = default);
 
-    bool TryCreateSavepoint(Guid id);
-    ValueTask<bool> TryCreateSavepointAsync(Guid id, CancellationToken ct = default);
-
     TDbContext GetDbContext<TDbContext>() where TDbContext : DbContext;
     ValueTask<TDbContext> GetDbContextAsync<TDbContext>(CancellationToken ct = default) where TDbContext : DbContext;
 

src/CodeOfChaos.Types.UnitOfWork/ReadonlyUnitOfWork.cs

@@ -21,23 +21,47 @@ protected async override ValueTask<TDbContext> GetDbContextAsync(CancellationTok
         return dbContext;
     }
 
+    protected override TDbContext GetDbContext() {
+        TDbContext dbContext = base.GetDbContext();
+        dbContext.SetAsReadonly();
+        return dbContext;
+    }
+
     // -----------------------------------------------------------------------------------------------------------------
     // Methods
     // -----------------------------------------------------------------------------------------------------------------
+    public override void SaveChanges() 
+        => throw new NotSupportedException("ReadonlyUnitOfWork cannot save changes.");
+
     public override ValueTask SaveChangesAsync(CancellationToken ct = default) 
         => throw new NotSupportedException("ReadonlyUnitOfWork cannot save changes.");
 
+    public override bool TryCommitTransaction() 
+        => throw new NotSupportedException("ReadonlyUnitOfWork cannot commit transactions.");
+    
     public override ValueTask<bool> TryCommitTransactionAsync(CancellationToken ct = default) 
         => throw new NotSupportedException("ReadonlyUnitOfWork cannot commit transactions.");
-
+    
+    public override bool TryCreateTransaction() 
+        => throw new NotSupportedException("ReadonlyUnitOfWork cannot create transactions.");
+    
     public override ValueTask<bool> TryCreateTransactionAsync(CancellationToken ct = default) 
         => throw new NotSupportedException("ReadonlyUnitOfWork cannot create transactions.");
+    
+    public override bool TryRollbackTransaction() 
+        => throw new NotSupportedException("ReadonlyUnitOfWork cannot rollback transactions.");
 
     public override ValueTask<bool> TryRollbackTransactionAsync(CancellationToken ct = default) 
         => throw new NotSupportedException("ReadonlyUnitOfWork cannot rollback transactions.");
+    
+    public override bool TryRollbackToSavepoint(Guid id) 
+        => throw new NotSupportedException("ReadonlyUnitOfWork cannot rollback to savepoints.");
 
     public override ValueTask<bool> TryRollbackToSavepointAsync(Guid id, CancellationToken ct = default) 
         => throw new NotSupportedException("ReadonlyUnitOfWork cannot rollback to savepoints.");
+    
+    public override bool TryCreateSavepoint(Guid id) 
+        => throw new NotSupportedException("ReadonlyUnitOfWork cannot create savepoints.");
 
     public override ValueTask<bool> TryCreateSavepointAsync(Guid id, CancellationToken ct = default) 
         => throw new NotSupportedException("ReadonlyUnitOfWork cannot create savepoints.");

src/CodeOfChaos.Types.UnitOfWork/UnitOfWork.cs

@@ -41,7 +41,7 @@ protected virtual async ValueTask<TDbContext> GetDbContextAsync(CancellationToke
 
     protected virtual TDbContext GetDbContext() => _lazyDb.Value;
 
-    public bool TryCreateTransaction() {
+    public virtual bool TryCreateTransaction() {
         if (_transaction != null) return false;
 
         var dbContext = GetDbContext<TDbContext>();
@@ -75,7 +75,7 @@ public virtual async ValueTask<bool> TryCreateTransactionAsync(CancellationToken
         }
     }
 
-    public void SaveChanges() {
+    public virtual void SaveChanges() {
         DbContext dbContext = GetDbContext<TDbContext>();
         dbContext.SaveChanges();
     }
@@ -85,7 +85,7 @@ public virtual async ValueTask SaveChangesAsync(CancellationToken ct = default)
         await dbContext.SaveChangesAsync(ct);
     }
 
-    public bool TryCommitTransaction() {
+    public virtual bool TryCommitTransaction() {
         if (_transaction == null) return false;
 
         lock (_transactionLock) {
@@ -111,7 +111,7 @@ public virtual async ValueTask<bool> TryCommitTransactionAsync(CancellationToken
         }
     }
 
-    public bool TryRollbackTransaction() {
+    public virtual bool TryRollbackTransaction() {
         if (_transaction == null) return false;
 
         _transaction.Rollback();
@@ -131,7 +131,7 @@ public virtual async ValueTask<bool> TryRollbackTransactionAsync(CancellationTok
         return true;
     }
 
-    public bool TryRollbackToSavepoint(Guid id) {
+    public virtual bool TryRollbackToSavepoint(Guid id) {
         if (_transaction == null) return false;
         if (!_transaction.SupportsSavepoints) return false;
 
@@ -148,7 +148,7 @@ public virtual async ValueTask<bool> TryRollbackToSavepointAsync(Guid id, Cancel
         return true;
     }
 
-    public bool TryCreateSavepoint(Guid id) {
+    public virtual bool TryCreateSavepoint(Guid id) {
         if (_transaction == null) return false;
         if (!_transaction.SupportsSavepoints) return false;
 
@@ -165,7 +165,7 @@ public virtual async ValueTask<bool> TryCreateSavepointAsync(Guid id, Cancellati
         return true;
     }
 
-    public T GetDbContext<T>() where T : DbContext {
+    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();
@@ -181,7 +181,7 @@ public virtual async ValueTask<T> GetDbContextAsync<T>(CancellationToken ct = de
         return Unsafe.As<TDbContext, T>(ref dbContext);
     }
 
-    public TRepo GetRepository<TRepo>() where TRepo : class, IUnitOfWorkRepository {
+    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>();