Bump version to 1.1.1 in project file

Updated DigitalData.Core.Exceptions.csproj to set <Version>, <AssemblyVersion>, and <FileVersion> to 1.1.1, replacing the previous 1.1.0 values. No other changes were made.

DigitalData.Core.Abstraction.Application/DigitalData.Core.Abstraction.Application.csproj

@@ -12,9 +12,9 @@
     <PackageIcon>core_icon.png</PackageIcon>
     <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
     <PackageTags>digital data core application clean architecture abstraction</PackageTags>
-    <Version>1.5.0</Version>
+    <Version>1.6.0</Version>
-    <AssemblyVersion>1.5.0</AssemblyVersion>
+    <AssemblyVersion>1.6.0</AssemblyVersion>
-    <FileVersion>1.5.0</FileVersion>
+    <FileVersion>1.6.0</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>

DigitalData.Core.Exceptions/BadRequestException.cs

@@ -19,4 +19,13 @@ public class BadRequestException : Exception
     public BadRequestException(string? message) : base(message)
     {
     }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BadRequestException"/> class with a specified error message and inner exception.
+    /// </summary>
+    /// <param name="message">The message that describes the error.</param>
+    /// <param name="innerException">The exception that caused the current exception.</param>
+    public BadRequestException(string? message, Exception? innerException) : base(message, innerException)
+    {
+    }
 }

DigitalData.Core.Exceptions/DigitalData.Core.Exceptions.csproj

@@ -17,9 +17,9 @@
 	<RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
 	<PackAsTool>False</PackAsTool>
 	<PackageIcon>core_icon.png</PackageIcon>
-	<Version>1.1.0</Version>
+	<Version>1.1.1</Version>
-	<AssemblyVersion>1.1.0</AssemblyVersion>
+	<AssemblyVersion>1.1.1</AssemblyVersion>
-	<FileVersion>1.1.0</FileVersion>
+	<FileVersion>1.1.1</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>

DigitalData.Core.Infrastructure/DbRepository.cs

@@ -100,9 +100,9 @@ namespace DigitalData.Core.Infrastructure
         #region Read
         public virtual IQueryable<TEntity> Query => Entities.AsNoTracking();
 
-        public IQueryable<TEntity> QueryRaw([NotParameterized] string sql, params object[] parameters) => Entities.FromSqlRaw(sql, parameters);
+        public virtual IQueryable<TEntity> QueryRaw([NotParameterized] string sql, params object[] parameters) => Entities.FromSqlRaw(sql, parameters).AsNoTracking();
 
-        public IQueryable<TEntity> QueryInterpolated([NotParameterized] FormattableString sql) => Entities.FromSqlInterpolated(sql);
+        public virtual IQueryable<TEntity> QueryInterpolated([NotParameterized] FormattableString sql) => Entities.FromSqlInterpolated(sql).AsNoTracking();
 
         public virtual IQueryable<TEntity> Where(Expression<Func<TEntity, bool>> expression) => Entities.AsNoTracking().Where(expression);
 

DigitalData.Core.Infrastructure/DependencyInjection.cs

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

DigitalData.Core.Infrastructure/DigitalData.Core.Infrastructure.csproj

@@ -13,9 +13,9 @@
     <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
     <RepositoryType>digital data core abstractions clean architecture</RepositoryType>
     <PackageTags>digital data core infrastructure clean architecture</PackageTags>
-    <Version>2.5.2</Version>
+    <Version>2.6.1</Version>
-    <AssemblyVersion>2.5.2</AssemblyVersion>
+    <AssemblyVersion>2.6.1</AssemblyVersion>
-    <FileVersion>2.5.2</FileVersion>
+    <FileVersion>2.6.1</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>