phase 1: more test, more fix 🐛

Author: thangchung

.vs/netcorekit/v16/.suo

@@ -32,6 +32,10 @@ public abstract class AggregateRootWithIdBase<TId> : EntityWithIdBase<TId>, IAgg
         private readonly IDictionary<Type, Action<object>> _handlers = new ConcurrentDictionary<Type, Action<object>>();
         private readonly List<IEvent> _uncommittedEvents = new List<IEvent>();
 
+        protected AggregateRootWithIdBase() : this(default)
+        {
+        }
+
         protected AggregateRootWithIdBase(TId id) : base(id)
         {
             Created = GenerateDateTime();

src/NetCoreKit.Domain/AggregateRoot.cs

@@ -11,7 +11,7 @@ public interface IEntity : IEntityWithId<Guid>
 
     /// <inheritdoc />
     /// <summary>
-    ///     Supertype for all Entity types
+    ///  Supertype for all Entity types
     /// </summary>
     public interface IEntityWithId<TId> : IIdentityWithId<TId>
     {
@@ -30,7 +30,7 @@ protected EntityBase(Guid id) : base(id)
 
     /// <inheritdoc />
     /// <summary>
-    ///     Source: https://github.com/VaughnVernon/IDDD_Samples_NET
+    ///  Source: https://github.com/VaughnVernon/IDDD_Samples_NET
     /// </summary>
     public abstract class EntityWithIdBase<TId> : IEntityWithId<TId>
     {

src/NetCoreKit.Domain/Entity.cs

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netcoreapp2.2</TargetFramework>
-
+    <LangVersion>7.3</LangVersion>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 

src/NetCoreKit.Infrastructure.EfCore.Tests/NetCoreKit.Infrastructure.EfCore.Tests.csproj

@@ -10,8 +10,24 @@
 
 namespace NetCoreKit.Infrastructure.EfCore.Tests
 {
+    public class TestEvent : EventBase
+    {
+    }
+
     public class TestEntity : AggregateRootBase
     {
+        public TestEntity()
+        {
+            AddEvent(new TestEvent());
+        }
+    }
+
+    public class TestEntityWithId : AggregateRootWithIdBase<int>
+    {
+        public TestEntityWithId()
+        {
+            AddEvent(new TestEvent());
+        }
     }
 
     public class TestDbContext : AppDbContext
@@ -46,9 +62,16 @@ public async Task CanCommandOnGenericRepo()
         {
             // command
             var uow = _services.BuildServiceProvider().GetService<IUnitOfWorkAsync>();
+
+            // without id type, default is Guid
             var testCommandRepo = uow.RepositoryAsync<TestEntity>();
             await testCommandRepo.AddAsync(new TestEntity());
             await testCommandRepo.AddAsync(new TestEntity());
+
+            // with int type for id
+            var testCommandRepoWithId = uow.RepositoryAsync<TestEntityWithId, int>();
+            await testCommandRepoWithId.AddAsync(new TestEntityWithId());
+
             var result = await uow.SaveChangesAsync(default);
 
             // assert
@@ -60,11 +83,18 @@ public async Task CanQueryOnGenericRepo()
         {
             // query
             var repoFactory = _services.BuildServiceProvider().GetService<IQueryRepositoryFactory>();
+
+            // without id type, default is Guid
             var testQueryRepo = repoFactory.QueryRepository<TestEntity>();
-            var result = await testQueryRepo.ListAsync<TestDbContext, TestEntity>();
+            var result1 = await testQueryRepo.ListAsync<TestDbContext, TestEntity>();
+
+            // with int type for id
+            var testQueryRepoWithId = repoFactory.QueryRepository<TestEntityWithId, int>();
+            var result2 = await testQueryRepoWithId.ListAsync<TestDbContext, TestEntityWithId, int>();
 
             // assert
-            Assert.NotNull(result.ToList());
+            Assert.NotNull(result1.ToList());
+            Assert.NotNull(result2.ToList());
         }
     }
 }

src/NetCoreKit.Infrastructure.EfCore.Tests/RepositoryTest.cs

@@ -54,39 +54,62 @@ public override int SaveChanges()
         }
 
         /// <summary>
-        /// Source:
-        /// https://github.com/ardalis/CleanArchitecture/blob/master/src/CleanArchitecture.Infrastructure/Data/AppDbContext.cs
+        /// Source: https://github.com/ardalis/CleanArchitecture/blob/master/src/CleanArchitecture.Infrastructure/Data/AppDbContext.cs
         /// </summary>
         private void SaveChangesWithEvents(IDomainEventDispatcher domainEventDispatcher)
         {
-            var entitiesWithEvents = ChangeTracker
-                .Entries()
-                .Select(e => e.Entity)
+            var entities = ChangeTracker.Entries().Select(e => e.Entity);
+
+            entities
                 .Where(e =>
                     !e.GetType().BaseType.IsGenericType &&
                     typeof(AggregateRootBase).IsAssignableFrom(e.GetType()))
-                .Where(e => ((IAggregateRoot)e).GetUncommittedEvents().Any())
+                .Select(aggregateRoot =>
+                {
+                    var events = ((IAggregateRoot)aggregateRoot).GetUncommittedEvents();
+
+                    foreach (var domainEvent in events)
+                        domainEventDispatcher.Dispatch(domainEvent);
+
+                    ((IAggregateRoot)aggregateRoot).GetUncommittedEvents().Clear();
+                    return aggregateRoot;
+                })
                 .ToArray();
 
-            foreach (var entity in entitiesWithEvents)
-            {
-                var events = ((IAggregateRoot)entity).GetUncommittedEvents().ToArray();
-                ((IAggregateRoot)entity).GetUncommittedEvents().Clear();
-                foreach (var domainEvent in events)
-                    domainEventDispatcher.Dispatch(domainEvent);
-            }
+            entities
+                .Where(e =>
+                    e.GetType().BaseType.IsGenericType &&
+                    typeof(AggregateRootWithIdBase<>).IsAssignableFrom(e.GetType().BaseType.GetGenericTypeDefinition()))
+                .Select(aggregateRoot =>
+                {
+                    //todo: need a better code to avoid dynamic
+                    var events = ((dynamic)aggregateRoot).GetUncommittedEvents();
+
+                    foreach (var domainEvent in events)
+                        domainEventDispatcher.Dispatch(domainEvent);
+
+                    ((dynamic)aggregateRoot).GetUncommittedEvents().Clear();
+                    return aggregateRoot;
+                })
+                .ToArray();
         }
 
         private static void RegisterEntities(ModelBuilder modelBuilder, IEnumerable<Type> typeToRegisters)
         {
             var concreteTypes = typeToRegisters.Where(x => !x.GetTypeInfo().IsAbstract && !x.GetTypeInfo().IsInterface);
-            var types = concreteTypes
-                .Where(x =>
-                    typeof(EntityBase).IsAssignableFrom(x) ||
-                    typeof(AggregateRootBase).IsAssignableFrom(x)
-                );
+            var types = new List<Type>();
 
-            foreach (var type in types) modelBuilder.Entity(type);
+            foreach (var concreteType in concreteTypes)
+            {
+                if (concreteType.BaseType != null &&
+                    (typeof(AggregateRootBase).IsAssignableFrom(concreteType) ||
+                     (concreteType.GetTypeInfo().BaseType.IsGenericType &&
+                      typeof(AggregateRootWithIdBase<>).IsAssignableFrom(concreteType.GetTypeInfo().BaseType.GetGenericTypeDefinition())
+                    )))
+                {
+                    modelBuilder.Entity(concreteType);
+                }
+            }
         }
 
         private static void RegisterConvention(ModelBuilder modelBuilder)