Fix: Removal of Attach and Detach and rename to IToUnitOfWorkRepository

Author: AnnaSasDev

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

@@ -5,7 +5,4 @@ namespace CodeOfChaos.Types.UnitOfWork;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-public interface ICanAttachToUnitOfWork {
-    void Attach(IUnitOfWork unitOfWork);
-    void Detach(IUnitOfWork unitOfWork);
-}
+public interface IToUnitOfWorkRepository;

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

@@ -20,5 +20,5 @@ public interface IUnitOfWork : IAsyncDisposable {
 
     ValueTask<TDbContext> GetDbContextAsync<TDbContext>(CancellationToken ct = default) where TDbContext : DbContext;
 
-    TRepo GetRepository<TRepo>() where TRepo : class, ICanAttachToUnitOfWork;
+    TRepo GetRepository<TRepo>() where TRepo : class, IToUnitOfWorkRepository;
 }

src/CodeOfChaos.Types.UnitOfWork/UnitOfWork.cs

@@ -14,7 +14,7 @@ namespace CodeOfChaos.Types.UnitOfWork;
 public class UnitOfWork<TDbContext>(IDbContextFactory<TDbContext> dbContextFactory, IServiceScope serviceScope) : IUnitOfWork where TDbContext : DbContext{
     private readonly AsyncLazy<TDbContext> _db = new(async ct => await dbContextFactory.CreateDbContextAsync(ct));
     private IDbContextTransaction? _transaction;
-    private ConcurrentDictionary<Type, ICanAttachToUnitOfWork> AttachedRepositories { get; } = [];
+    private ConcurrentDictionary<Type, IToUnitOfWorkRepository> AttachedRepositories { get; } = [];
 
     // -----------------------------------------------------------------------------------------------------------------
     // Methods
@@ -84,13 +84,12 @@ public virtual async ValueTask<T> GetDbContextAsync<T>(CancellationToken ct = de
         return dbContext as T ?? throw new InvalidCastException($"Cannot cast DbContext of type '{dbContext.GetType()}' to '{typeof(T)}'");
     }
 
-    public virtual TRepo GetRepository<TRepo>() where TRepo : class, ICanAttachToUnitOfWork {
-        if (AttachedRepositories.TryGetValue(typeof(TRepo), out ICanAttachToUnitOfWork? cachedRepo) && cachedRepo is TRepo castedCachedRepo) return castedCachedRepo;
+    public virtual TRepo GetRepository<TRepo>() where TRepo : class, IToUnitOfWorkRepository {
+        if (AttachedRepositories.TryGetValue(typeof(TRepo), out IToUnitOfWorkRepository? cachedRepo) && cachedRepo is TRepo castedCachedRepo) return castedCachedRepo;
 
         // Cache miss so we create a new instance
         var repo = serviceScope.ServiceProvider.GetRequiredService<TRepo>();
 
-        repo.Attach(this);
         AttachedRepositories.AddOrUpdate(typeof(TRepo), repo); 
         return repo;
     }
@@ -99,12 +98,6 @@ public virtual async ValueTask DisposeAsync() {
         if (_transaction != null) await TryRollbackTransactionAsync();
 
         if (!AttachedRepositories.IsEmpty) {
-            // First detach all references to this unit of work
-            foreach ((_, ICanAttachToUnitOfWork repo) in AttachedRepositories) {
-                repo.Detach(this);
-            }
-            
-            // Then clear our own reference to them
             AttachedRepositories.Clear();
         }
 

tests/Tests.CodeOfChaos.Types.UnitOfWork/UnitOfWorkTests.cs

@@ -193,14 +193,14 @@ public async Task GetDbContextAsync_ShouldThrowForUnsupportedDbContextType() {
     [Test]
     public async Task GetRepository_ShouldRetrieveRepositoryFromServiceProvider() {
         // Arrange
-        var mockRepository = new Mock<ICanAttachToUnitOfWork>();
+        var mockRepository = new Mock<IToUnitOfWorkRepository>();
         _serviceProvider
-            .Setup(sp => sp.GetService(typeof(ICanAttachToUnitOfWork)))
+            .Setup(sp => sp.GetService(typeof(IToUnitOfWorkRepository)))
             .Returns(mockRepository.Object);
 
 
         // Act
-        var repository = _unitOfWork.GetRepository<ICanAttachToUnitOfWork>();
+        var repository = _unitOfWork.GetRepository<IToUnitOfWorkRepository>();
 
         // Assert
         await Assert.That(repository).IsNotNull();