From 1e3cba6fdf2ebcc7d6cf1d895f88bbc5f2ba70de Mon Sep 17 00:00:00 2001
From: TekH <h.tek@digitaldata.works>
Date: Fri, 19 Dec 2025 10:09:04 +0100
Subject: [PATCH] Refactor DependencyInjection and RepositoryConfiguration
 classes

Restructure code for improved readability and maintainability. Move RepositoryConfiguration as a nested public class inside DependencyInjection, group related service registration logic, and clarify method organization. No functional changes.
---
 .../DependencyInjection.cs                    | 200 +++++++++---------
 1 file changed, 96 insertions(+), 104 deletions(-)

diff --git a/DigitalData.Core.Infrastructure/DependencyInjection.cs b/DigitalData.Core.Infrastructure/DependencyInjection.cs
index 2260b73..8e65079 100644
--- a/DigitalData.Core.Infrastructure/DependencyInjection.cs
+++ b/DigitalData.Core.Infrastructure/DependencyInjection.cs
@@ -11,142 +11,134 @@ using System.Linq;
 #endif
 
 namespace DigitalData.Core.Infrastructure
-#if NET
-    ;
-#elif NETFRAMEWORK
-    {
-#endif
-
-public static class DependencyInjection
 {
-    public static IServiceCollection AddDbRepository(this IServiceCollection services, Action<RepositoryConfiguration> options)
-    {
-        // register services from configuration
-        var cfg = new RepositoryConfiguration();
-        options.Invoke(cfg);
-        cfg.RegisterAllServices(services);
-
-        return services;
-    }
-
-    public class RepositoryConfiguration
+    public static class DependencyInjection
     {
-        // 1. register from assembly
-        private readonly Queue<Action<IServiceCollection>> RegsFromAssembly = new Queue<Action<IServiceCollection>>();
-
-        // 2. register entities (can overwrite)
-        private readonly Queue<Action<IServiceCollection>> RegsEntity = new Queue<Action<IServiceCollection>>();
+        public static IServiceCollection AddDbRepository(this IServiceCollection services, Action<RepositoryConfiguration> options)
+        {
+            // register services from configuration
+            var cfg = new RepositoryConfiguration();
+            options.Invoke(cfg);
+            cfg.RegisterAllServices(services);
 
-        // 3. register db set factories (can overwrite)
-        private readonly Queue<Action<IServiceCollection>> RegsDbSetFactory = new Queue<Action<IServiceCollection>>();
+            return services;
+        }
 
-        // 4. register repository
-        private readonly Queue<Action<IServiceCollection>> RegsRepository = new Queue<Action<IServiceCollection>>();
-        
-        internal void RegisterAllServices(IServiceCollection services)
+        public class RepositoryConfiguration
         {
             // 1. register from assembly
-            RegsFromAssembly.InvokeAll(services);
+            private readonly Queue<Action<IServiceCollection>> RegsFromAssembly = new Queue<Action<IServiceCollection>>();
 
             // 2. register entities (can overwrite)
-            RegsEntity.InvokeAll(services);
+            private readonly Queue<Action<IServiceCollection>> RegsEntity = new Queue<Action<IServiceCollection>>();
 
             // 3. register db set factories (can overwrite)
-            RegsDbSetFactory.InvokeAll(services);
-        }
+            private readonly Queue<Action<IServiceCollection>> RegsDbSetFactory = new Queue<Action<IServiceCollection>>();
 
-        internal RepositoryConfiguration() { }
+            // 4. register repository
+            private readonly Queue<Action<IServiceCollection>> RegsRepository = new Queue<Action<IServiceCollection>>();
 
-        public void RegisterFromAssembly<TDbContext>(Assembly assembly) where TDbContext : DbContext
-        {
-            void reg(IServiceCollection services)
+            internal void RegisterAllServices(IServiceCollection services)
             {
-                // scan all types in the Assembly
-                var entityTypes = assembly.GetTypes()
-                    .Where(t => t.IsClass && !t.IsAbstract && t.GetCustomAttribute<TableAttribute>() != null);
+                // 1. register from assembly
+                RegsFromAssembly.InvokeAll(services);
+
+                // 2. register entities (can overwrite)
+                RegsEntity.InvokeAll(services);
+
+                // 3. register db set factories (can overwrite)
+                RegsDbSetFactory.InvokeAll(services);
+            }
+
+            internal RepositoryConfiguration() { }
 
-                foreach (var entityType in entityTypes)
+            public void RegisterFromAssembly<TDbContext>(Assembly assembly) where TDbContext : DbContext
+            {
+                void reg(IServiceCollection services)
                 {
-                    #region Repository
-                    /// register repository
-                    // create generic DbRepository<DbContext, TEntity> type
-                    var repositoryType = typeof(DbRepository<,>).MakeGenericType(typeof(TDbContext), entityType);
-                    var interfaceType = typeof(IRepository<>).MakeGenericType(entityType);
-
-                    // add into DI container as Scoped
-                    services.AddScoped(interfaceType, repositoryType);
-                    #endregion Repository
-
-                    #region DbSetFactory
-                    /// register DbSetFactory
-                    var addDbSetFactoryMethod = typeof(DependencyInjection)
-                        .GetMethod(nameof(AddDbSetFactory),
-                                   BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
-
-                    var genericMethod = addDbSetFactoryMethod
+                    // scan all types in the Assembly
+                    var entityTypes = assembly.GetTypes()
+                        .Where(t => t.IsClass && !t.IsAbstract && t.GetCustomAttribute<TableAttribute>() != null);
+
+                    foreach (var entityType in entityTypes)
+                    {
+                        #region Repository
+                        /// register repository
+                        // create generic DbRepository<DbContext, TEntity> type
+                        var repositoryType = typeof(DbRepository<,>).MakeGenericType(typeof(TDbContext), entityType);
+                        var interfaceType = typeof(IRepository<>).MakeGenericType(entityType);
+
+                        // add into DI container as Scoped
+                        services.AddScoped(interfaceType, repositoryType);
+                        #endregion Repository
+
+                        #region DbSetFactory
+                        /// register DbSetFactory
+                        var addDbSetFactoryMethod = typeof(DependencyInjection)
+                            .GetMethod(nameof(AddDbSetFactory),
+                                       BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+
+                        var genericMethod = addDbSetFactoryMethod
 #if NET
                                         !
 #endif
-                                        .MakeGenericMethod(typeof(TDbContext), entityType);
-                    genericMethod.Invoke(null, new [] { services, null });
-                    #endregion DbSetFactory
+                                            .MakeGenericMethod(typeof(TDbContext), entityType);
+                        genericMethod.Invoke(null, new [] { services, null });
+                        #endregion DbSetFactory
+                    }
                 }
-            }
 
-            RegsFromAssembly.Enqueue(reg);
-        }
+                RegsFromAssembly.Enqueue(reg);
+            }
 
-        public void RegisterEntity<TDbContext, TEntity>(Func<TDbContext, DbSet<TEntity>>
+            public void RegisterEntity<TDbContext, TEntity>(Func<TDbContext, DbSet<TEntity>>
 #if NET
             ?
 #endif
-            dbSetFactory = null)
-            where TDbContext : DbContext
-            where TEntity : class
-        {
-            void reg(IServiceCollection services)
-                => services
-                    .AddScoped<IRepository<TEntity>, DbRepository<TDbContext, TEntity>>()
-                    .AddDbSetFactory(dbSetFactory);
+                dbSetFactory = null)
+                where TDbContext : DbContext
+                where TEntity : class
+            {
+                void reg(IServiceCollection services)
+                    => services
+                        .AddScoped<IRepository<TEntity>, DbRepository<TDbContext, TEntity>>()
+                        .AddDbSetFactory(dbSetFactory);
+
+                RegsEntity.Enqueue(reg);
+            }
+
+            public void RegisterDbSetFactory<TDbContext, TEntity>(Func<TDbContext, DbSet<TEntity>> dbSetFactory)
+                where TDbContext : DbContext
+                where TEntity : class
+                => RegsDbSetFactory.Enqueue(s => s.AddDbSetFactory(dbSetFactory));
 
-            RegsEntity.Enqueue(reg);
+            public void RegisterDefaultRepository<TDbContext>()
+                where TDbContext : DbContext
+                => RegsRepository.Enqueue(s => s.AddScoped<IRepository, DbRepository<TDbContext>>());
         }
 
-        public void RegisterDbSetFactory<TDbContext, TEntity>(Func<TDbContext, DbSet<TEntity>> dbSetFactory)
-            where TDbContext : DbContext
-            where TEntity : class
-            => RegsDbSetFactory.Enqueue(s => s.AddDbSetFactory(dbSetFactory));
-    
-        public void RegisterDefaultRepository<TDbContext>()
-            where TDbContext : DbContext
-            => RegsRepository.Enqueue(s => s.AddScoped<IRepository, DbRepository<TDbContext>>());
-    }
-    
-    private static void InvokeAll<T>(this Queue<Action<T>> queue, T services)
-    {
-        while (queue.Count > 0)
-            queue.Dequeue().Invoke(services);
-    }
+        private static void InvokeAll<T>(this Queue<Action<T>> queue, T services)
+        {
+            while (queue.Count > 0)
+                queue.Dequeue().Invoke(services);
+        }
 
-    internal static IServiceCollection AddDbSetFactory<TDbContext, TEntity>(this IServiceCollection services, Func<TDbContext, DbSet<TEntity>>
+        internal static IServiceCollection AddDbSetFactory<TDbContext, TEntity>(this IServiceCollection services, Func<TDbContext, DbSet<TEntity>>
 #if NET
         ?
 #endif
-        create = null)
-        where TDbContext : DbContext
-        where TEntity : class
-    {
+            create = null)
+            where TDbContext : DbContext
+            where TEntity : class
+        {
 #if NET
-        create ??= ctx => ctx.Set<TEntity>();
+            create ??= ctx => ctx.Set<TEntity>();
 #elif NETFRAMEWORK
-        if(create is null)
-            create = ctx => ctx.Set<TEntity>();
+            if(create is null)
+                create = ctx => ctx.Set<TEntity>();
 #endif
-        services.AddSingleton(_ => new DbSetFactory<TDbContext, TEntity>(create));
-        return services;
-    }
-}
-
-#if NETFRAMEWORK
+            services.AddSingleton(_ => new DbSetFactory<TDbContext, TEntity>(create));
+            return services;
+        }
     }
-#endif
\ No newline at end of file
+}
\ No newline at end of file