Enhance EF Core integration and event handling

- Added comments and improved logging in Program.cs, ApplicationDbInitializer.cs, and DatabaseInitializer.cs for better clarity.
- Introduced CollectionExtensions class with IsNullOrEmpty and AddIfNotContains methods.
- Updated ApplicationDbContext to include a Connection property for Dapper access.
- Added DatabaseSettings class with properties for DBProvider and ConnectionString.
- Enhanced repository event handling with EventAddingRepositoryDecorator.
- Introduced new event classes: EntityCreatedEvent, EntityDeletedEvent, and EntityUpdatedEvent.
- Added MultitenantDatabaseInitializer for multi-tenant database initialization.
- Commented out DapperRepository class, indicating it may be under review.

Author: GioemaNocco

src/Genocs.Core.Demo.WebApi/Program.cs

@@ -65,6 +65,7 @@
 
 app.UseGenocs();
 
+// Use it only  in case you are using EF Core
 await app.Services.InitializeDatabasesAsync();
 
 // Configure the HTTP request pipeline.

src/Genocs.Core/Collections/Extensions/CollectionExtensions.cs

@@ -1,40 +1,35 @@
-namespace Genocs.Core.Collections.Extensions
+namespace Genocs.Core.Collections.Extensions;
+
+/// <summary>
+/// Extension methods for Collections.
+/// </summary>
+public static class CollectionExtensions
 {
+    /// <summary>
+    /// Checks whatever given collection object is null or has no item.
+    /// </summary>
+    public static bool IsNullOrEmpty<T>(this ICollection<T> source)
+    {
+        return source == null || source.Count <= 0;
+    }
 
     /// <summary>
-    /// Extension methods for Collections.
+    /// Adds an item to the collection if it's not already in the collection.
     /// </summary>
-    public static class CollectionExtensions
+    /// <param name="source">Collection.</param>
+    /// <param name="item">Item to check and add.</param>
+    /// <typeparam name="T">Type of the items in the collection.</typeparam>
+    /// <returns>Returns True if added, returns False if not.</returns>
+    public static bool AddIfNotContains<T>(this ICollection<T> source, T item)
     {
-        /// <summary>
-        /// Checks whatever given collection object is null or has no item.
-        /// </summary>
-        public static bool IsNullOrEmpty<T>(this ICollection<T> source)
-        {
-            return source == null || source.Count <= 0;
-        }
+        ArgumentNullException.ThrowIfNull(source);
 
-        /// <summary>
-        /// Adds an item to the collection if it's not already in the collection.
-        /// </summary>
-        /// <param name="source">Collection.</param>
-        /// <param name="item">Item to check and add.</param>
-        /// <typeparam name="T">Type of the items in the collection.</typeparam>
-        /// <returns>Returns True if added, returns False if not.</returns>
-        public static bool AddIfNotContains<T>(this ICollection<T> source, T item)
+        if (source.Contains(item))
         {
-            if (source == null)
-            {
-                throw new ArgumentNullException("source");
-            }
-
-            if (source.Contains(item))
-            {
-                return false;
-            }
-
-            source.Add(item);
-            return true;
+            return false;
         }
+
+        source.Add(item);
+        return true;
     }
 }

src/Genocs.Core/Domain/Events/EntityCreatedEvent.cs

@@ -0,0 +1,19 @@
+using Genocs.Core.Domain.Entities;
+
+namespace Genocs.Core.Domain.Events;
+
+public static class EntityCreatedEvent
+{
+    public static EntityCreatedEvent<TEntity> WithEntity<TEntity>(TEntity entity)
+        where TEntity : IEntity
+        => new(entity);
+}
+
+public class EntityCreatedEvent<TEntity> : DomainEvent
+    where TEntity : IEntity
+{
+    internal EntityCreatedEvent(TEntity entity)
+        => Entity = entity;
+
+    public TEntity Entity { get; }
+}

src/Genocs.Core/Domain/Events/EntityDeletedEvent.cs

@@ -0,0 +1,19 @@
+using Genocs.Core.Domain.Entities;
+
+namespace Genocs.Core.Domain.Events;
+
+public static class EntityDeletedEvent
+{
+    public static EntityDeletedEvent<TEntity> WithEntity<TEntity>(TEntity entity)
+        where TEntity : IEntity
+        => new(entity);
+}
+
+public class EntityDeletedEvent<TEntity> : DomainEvent
+    where TEntity : IEntity
+{
+    internal EntityDeletedEvent(TEntity entity)
+        => Entity = entity;
+
+    public TEntity Entity { get; }
+}

src/Genocs.Core/Domain/Events/EntityUpdatedEvent.cs

@@ -0,0 +1,19 @@
+using Genocs.Core.Domain.Entities;
+
+namespace Genocs.Core.Domain.Events;
+
+public static class EntityUpdatedEvent
+{
+    public static EntityUpdatedEvent<TEntity> WithEntity<TEntity>(TEntity entity)
+        where TEntity : IEntity
+        => new(entity);
+}
+
+public class EntityUpdatedEvent<TEntity> : DomainEvent
+    where TEntity : IEntity
+{
+    internal EntityUpdatedEvent(TEntity entity)
+        => Entity = entity;
+
+    public TEntity Entity { get; }
+}

src/Genocs.Persistence.EFCore/Context/ApplicationDbContext.cs

@@ -1,5 +1,10 @@
+using System.Data;
 using Microsoft.EntityFrameworkCore;
 
 namespace Genocs.Persistence.EFCore.Context;
 
-public class ApplicationDbContext(DbContextOptions options) : DbContext(options);
+public class ApplicationDbContext(DbContextOptions options) : DbContext(options)
+{
+    // Used by Dapper
+    public IDbConnection Connection => Database.GetDbConnection();
+}

src/Genocs.Persistence.EFCore/DatabaseSettings.cs

@@ -2,9 +2,20 @@
 
 namespace Genocs.Persistence.EFCore;
 
+/// <summary>
+/// The DatabaseSettings class is used to configure the database connection settings.
+/// TODO: Rename to *Options and Move to *.Configuration namespace.
+/// </summary>
 public class DatabaseSettings : IValidatableObject
 {
+    /// <summary>
+    /// The database provider to use (e.g., SqlServer, MySql, PostgreSql).
+    /// </summary>
     public string DBProvider { get; set; } = string.Empty;
+
+    /// <summary>
+    /// The connection string to the database.
+    /// </summary>
     public string ConnectionString { get; set; } = string.Empty;
 
     public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)

src/Genocs.Persistence.EFCore/Extensions/EFCoreExtensions.cs

@@ -127,11 +127,11 @@ private static IServiceCollection AddRepositories(this IServiceCollection servic
                 sp.GetRequiredService(typeof(IRepository<>).MakeGenericType(aggregateRootType)));
 
             // Decorate the repositories with EventAddingRepositoryDecorators and expose them as IRepositoryWithEvents.
-            //services.AddScoped(typeof(IRepositoryWithEvents<>).MakeGenericType(aggregateRootType), sp =>
-            //    Activator.CreateInstance(
-            //        typeof(EventAddingRepositoryDecorator<>).MakeGenericType(aggregateRootType),
-            //        sp.GetRequiredService(typeof(IRepository<>).MakeGenericType(aggregateRootType)))
-            //    ?? throw new InvalidOperationException($"Couldn't create EventAddingRepositoryDecorator for aggregateRootType {aggregateRootType.Name}"));
+            services.AddScoped(typeof(IRepositoryWithEvents<>).MakeGenericType(aggregateRootType), sp =>
+                Activator.CreateInstance(
+                    typeof(EventAddingRepositoryDecorator<>).MakeGenericType(aggregateRootType),
+                    sp.GetRequiredService(typeof(IRepository<>).MakeGenericType(aggregateRootType)))
+                ?? throw new InvalidOperationException($"Couldn't create EventAddingRepositoryDecorator for aggregateRootType {aggregateRootType.Name}"));
         }
 
         return services;

src/Genocs.Persistence.EFCore/Initialization/ApplicationDbInitializer.cs

@@ -4,12 +4,22 @@
 
 namespace Genocs.Persistence.EFCore.Initialization;
 
+/// <summary>
+/// ApplicationDbInitializer is responsible for initializing the database.
+/// </summary>
 internal class ApplicationDbInitializer
 {
     private readonly ApplicationDbContext _dbContext;
     private readonly ApplicationDbSeeder _dbSeeder;
     private readonly ILogger<ApplicationDbInitializer> _logger;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ApplicationDbInitializer"/> class.
+    /// </summary>
+    /// <param name="dbContext">The DB Context.</param>
+    /// <param name="dbSeeder">the datebase seeder.</param>
+    /// <param name="logger">The logger.</param>
+    /// <exception cref="ArgumentNullException">The exception that is thrown when compulsory params are missing.</exception>
     public ApplicationDbInitializer(ApplicationDbContext dbContext, ApplicationDbSeeder dbSeeder, ILogger<ApplicationDbInitializer> logger)
     {
 
@@ -18,11 +28,16 @@ public ApplicationDbInitializer(ApplicationDbContext dbContext, ApplicationDbSee
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
     }
 
-    public async Task InitializeAsync(CancellationToken cancellationToken)
+    /// <summary>
+    /// Initializes the database.
+    /// </summary>
+    /// <param name="cancellationToken">The cancelation token.</param>
+    /// <returns>The task.</returns>
+    public virtual async Task InitializeAsync(CancellationToken cancellationToken)
     {
         if (_dbContext.Database.GetMigrations().Any())
         {
-            _logger.LogInformation("Applying migrations to the database.");
+            _logger.LogInformation("Find migrations that need to be apply. Applying migrations to the database.");
         }
 
         await Task.CompletedTask;

src/Genocs.Persistence.EFCore/Initialization/CustomSeederRunner.cs

@@ -3,15 +3,23 @@
 
 namespace Genocs.Persistence.EFCore.Initialization;
 
+/// <summary>
+/// CustomSeederRunner is responsible for running custom seeders.
+/// </summary>
+/// <param name="serviceProvider"></param>
 internal class CustomSeederRunner(IServiceProvider serviceProvider)
 {
-    private readonly ICustomSeeder[] _seeders = [.. serviceProvider.GetServices<ICustomSeeder>()];
-
+    /// <summary>
+    /// Runs the custom seeders.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The task.</returns>
     public async Task RunSeedersAsync(CancellationToken cancellationToken)
     {
-        foreach (var seeder in _seeders)
+        ICustomSeeder[] seeders = serviceProvider.GetServices<ICustomSeeder>().ToArray();
+        foreach (var seeder in seeders)
         {
             await seeder.InitializeAsync(cancellationToken);
         }
     }
-}
+}