Merge pull request #10 from XerProjects/feature-remove-aggregateid

Remove generic AggregateRootId argument from types. Use Guid as ID.

Author: joel-jeremy

Src/Xer.DomainDriven/AggregateRoot.cs

@@ -4,11 +4,11 @@
 
 namespace Xer.DomainDriven
 {
-    public abstract class AggregateRoot<TId> : Entity<TId>, IAggregateRoot<TId> where TId : IEquatable<TId>
+    public abstract class AggregateRoot : Entity, IAggregateRoot
     {
         #region Declarations
 
-        private readonly Queue<IDomainEvent<TId>> _uncommittedDomainEvents = new Queue<IDomainEvent<TId>>();
+        private readonly Queue<IDomainEvent> _uncommittedDomainEvents = new Queue<IDomainEvent>();
         private readonly DomainEventApplierRegistration _domainEventApplierRegistration = new DomainEventApplierRegistration();
 
         #endregion Declarations
@@ -19,7 +19,7 @@ public abstract class AggregateRoot<TId> : Entity<TId>, IAggregateRoot<TId> wher
         /// Constructor.
         /// </summary>
         /// <param name="aggregateRootId">Id of aggregate root.</param>
-        public AggregateRoot(TId aggregateRootId)
+        public AggregateRoot(Guid aggregateRootId)
             : base(aggregateRootId)
         {
         }
@@ -30,7 +30,7 @@ public AggregateRoot(TId aggregateRootId)
         /// <param name="aggregateRootId">Id of aggregate root.</param>
         /// <param name="created">Created date.</param>
         /// <param name="updated">Updated date.</param>
-        public AggregateRoot(TId aggregateRootId, DateTime created, DateTime updated)
+        public AggregateRoot(Guid aggregateRootId, DateTime created, DateTime updated)
             : base(aggregateRootId, created, updated)
         {
         }
@@ -45,15 +45,15 @@ public AggregateRoot(TId aggregateRootId, DateTime created, DateTime updated)
         /// Get an event stream of all the uncommitted domain events applied to the aggregate.
         /// </summary>
         /// <returns>Stream of uncommitted domain events.</returns>
-        IDomainEventStream<TId> IAggregateRoot<TId>.GetUncommitedDomainEvents()
+        IDomainEventStream IAggregateRoot.GetDomainEventsMarkedForCommit()
         {
-            return new DomainEventStream<TId>(Id, _uncommittedDomainEvents);
+            return new DomainEventStream(Id, _uncommittedDomainEvents);
         }
 
         // <summary>
         // Clear all internally tracked domain events.
         // </summary>
-        void IAggregateRoot<TId>.ClearUncommitedDomainEvents()
+        void IAggregateRoot.MarkDomainEventsAsCommitted()
         {
             _uncommittedDomainEvents.Clear();
         }
@@ -67,17 +67,17 @@ void IAggregateRoot<TId>.ClearUncommitedDomainEvents()
         /// </summary>
         /// <typeparam name="TDomainEvent">Domain event to be applied.</typeparam>
         /// <param name="domainEventApplier">Domain event applier.</param>
-        protected void RegisterDomainEventApplier<TDomainEvent>(Action<TDomainEvent> domainEventApplier) where TDomainEvent : class, IDomainEvent<TId>
+        protected void RegisterDomainEventApplier<TDomainEvent>(Action<TDomainEvent> domainEventApplier) where TDomainEvent : class, IDomainEvent
         {
             _domainEventApplierRegistration.RegisterApplierFor<TDomainEvent>(domainEventApplier);
         }
 
         /// <summary>
-        /// Apply domain event to this entity and mark domain event for commit.
+        /// Apply domain event to this aggregate root and mark domain event for commit.
         /// </summary>
         /// <typeparam name="TDomainEvent">Type of domain event to apply.</typeparam>
         /// <param name="domainEvent">Instance of domain event to apply.</param>
-        protected void ApplyDomainEvent<TDomainEvent>(TDomainEvent domainEvent) where TDomainEvent : IDomainEvent<TId>
+        protected void ApplyDomainEvent<TDomainEvent>(TDomainEvent domainEvent) where TDomainEvent : IDomainEvent
         {
             if (domainEvent == null)
             {
@@ -88,6 +88,41 @@ protected void ApplyDomainEvent<TDomainEvent>(TDomainEvent domainEvent) where TD
             InvokeDomainEventApplier(domainEvent);
         }
 
+        /// <summary>
+        /// Apply domain event to this aggregate root wihtout marking domain event for commit.
+        /// </summary>
+        /// <typeparam name="TDomainEvent">Type of domain event to replay.</typeparam>
+        /// <param name="domainEvent">Instance of domain event to replay.</param>
+        protected void ReplayDomainEvent<TDomainEvent>(TDomainEvent domainEvent) where TDomainEvent : IDomainEvent
+        {
+            if (domainEvent == null)
+            {
+                throw new ArgumentNullException(nameof(domainEvent));
+            }
+
+            // Invoke and track the event to save to event store.
+            InvokeDomainEventApplier(domainEvent, markDomainEventForCommit: false);
+        }
+
+        /// <summary>
+        /// Executes when a domain event is successfully applied.
+        /// </summary>
+        /// <param name="domainEvent">Successfully applied domain event.</param>
+        protected virtual void OnDomainEventApplied(IDomainEvent domainEvent)
+        {            
+            // Update timestamp.
+            Updated = domainEvent.TimeStamp;
+        }
+        
+        /// <summary>
+        /// Add domain event to list of tracked domain events.
+        /// </summary>
+        /// <param name="domainEvent">Domain event instance to track.</param>
+        protected virtual void MarkAppliedDomainEventForCommit(IDomainEvent domainEvent)
+        {
+            _uncommittedDomainEvents.Enqueue(domainEvent);
+        }
+
         #endregion Protected Methods
 
         #region Functions
@@ -98,22 +133,20 @@ protected void ApplyDomainEvent<TDomainEvent>(TDomainEvent domainEvent) where TD
         /// <typeparam name="TDomainEvent">Type of the domain event to handle.</typeparam>
         /// <param name="domainEvent">Domain event instance to handle.</param>
         /// <param name="markDomainEventForCommit">True, if domain event should be marked/tracked for commit. Otherwise, false - which means domain event should just be replayed.</param>
-        private void InvokeDomainEventApplier<TDomainEvent>(TDomainEvent domainEvent, bool markDomainEventForCommit = true) where TDomainEvent : IDomainEvent<TId>
+        private void InvokeDomainEventApplier<TDomainEvent>(TDomainEvent domainEvent, bool markDomainEventForCommit = true) where TDomainEvent : IDomainEvent
         {
-            Action<IDomainEvent<TId>> domainEventApplier = _domainEventApplierRegistration.GetApplierFor(domainEvent);
-            if (domainEventApplier == null)
+            if (!_domainEventApplierRegistration.TryGetApplierFor(domainEvent, out Action<IDomainEvent> domainEventApplier))
             {
-                throw new DomainEventNotAppliedException<TId>(domainEvent,
+                throw new DomainEventNotAppliedException(domainEvent,
                     $@"{GetType().Name} has no registered domain event applier to apply domain event of type {domainEvent.GetType().Name}.
-                    Register domain event appliers by calling {nameof(RegisterDomainEventApplier)} method during object construction.");
+                    Register domain event appliers by calling {nameof(RegisterDomainEventApplier)} method in constructor.");
             }
 
             try
             {
                 domainEventApplier.Invoke(domainEvent);
 
-                // Update timestamp.
-                Updated = domainEvent.TimeStamp;
+                OnDomainEventApplied(domainEvent);
 
                 if (markDomainEventForCommit)
                 {
@@ -122,20 +155,11 @@ private void InvokeDomainEventApplier<TDomainEvent>(TDomainEvent domainEvent, bo
             }
             catch (Exception ex)
             {
-                throw new DomainEventNotAppliedException<TId>(domainEvent,
+                throw new DomainEventNotAppliedException(domainEvent,
                     $"Exception occured while trying to apply domain event of type {domainEvent.GetType().Name}.",
                     ex);
             }
         }
-        
-        /// <summary>
-        /// Add domain event to list of tracked domain events.
-        /// </summary>
-        /// <param name="domainEvent">Domain event instance to track.</param>
-        private void MarkAppliedDomainEventForCommit(IDomainEvent<TId> domainEvent)
-        {
-            _uncommittedDomainEvents.Enqueue(domainEvent);
-        }
 
         #endregion Functions
 
@@ -146,14 +170,14 @@ private void MarkAppliedDomainEventForCommit(IDomainEvent<TId> domainEvent)
         /// </summary>
         private class DomainEventApplierRegistration
         {
-            private readonly IDictionary<Type, Action<IDomainEvent<TId>>> _applierByDomainEventType = new Dictionary<Type, Action<IDomainEvent<TId>>>();
+            private readonly Dictionary<Type, Action<IDomainEvent>> _applierByDomainEventType = new Dictionary<Type, Action<IDomainEvent>>();
 
             /// <summary>
             /// Register action to be executed for the domain event.
             /// </summary>
             /// <typeparam name="TDomainEvent">Type of domain event to apply.</typeparam>
             /// <param name="applier">Action to apply the domain event to the aggregate.</param>
-            public void RegisterApplierFor<TDomainEvent>(Action<TDomainEvent> applier) where TDomainEvent : class, IDomainEvent<TId>
+            public void RegisterApplierFor<TDomainEvent>(Action<TDomainEvent> applier) where TDomainEvent : class, IDomainEvent
             {
                 if (applier == null)
                 {
@@ -167,7 +191,7 @@ public void RegisterApplierFor<TDomainEvent>(Action<TDomainEvent> applier) where
                     throw new InvalidOperationException($"A domain event applier that applies {domainEventType.Name} has already been registered.");
                 }
 
-                Action<IDomainEvent<TId>> domainEventApplier = (d) =>
+                Action<IDomainEvent> domainEventApplier = (d) =>
                 {
                     TDomainEvent domainEvent = d as TDomainEvent;
                     if (domainEvent == null)
@@ -187,17 +211,16 @@ public void RegisterApplierFor<TDomainEvent>(Action<TDomainEvent> applier) where
             /// Get action to execute for the applied domain event.
             /// </summary>
             /// <param name="domainEvent">Domain event to apply.</param>
-            /// <returns>Action that applies the domain event to the aggregate.</returns>
-            public Action<IDomainEvent<TId>> GetApplierFor(IDomainEvent<TId> domainEvent)
+            /// <param name="domainEventApplier">Action that applies the domain event to the aggregate.</param>
+            /// <returns>True, if a registered domain event applier is found. Otherwise, false.</returns>
+            public bool TryGetApplierFor(IDomainEvent domainEvent, out Action<IDomainEvent> domainEventApplier)
             {
                 if (domainEvent == null)
                 {
                     throw new ArgumentNullException(nameof(domainEvent));
                 }
 
-                _applierByDomainEventType.TryGetValue(domainEvent.GetType(), out Action<IDomainEvent<TId>> domainEventAction);
-
-                return domainEventAction;
+                return _applierByDomainEventType.TryGetValue(domainEvent.GetType(), out domainEventApplier);
             }
         }
 

Src/Xer.DomainDriven/DomainEventStream.cs

@@ -5,13 +5,11 @@
 
 namespace Xer.DomainDriven
 {
-    public class DomainEventStream<TAggregateRootId> : IDomainEventStream<TAggregateRootId>, 
-                                                       IEnumerable<IDomainEvent<TAggregateRootId>> 
-                                                       where TAggregateRootId : IEquatable<TAggregateRootId>
+    public class DomainEventStream : IDomainEventStream, IEnumerable<IDomainEvent>
     {
         #region Declarations
 
-        private readonly ICollection<IDomainEvent<TAggregateRootId>> _domainEvents;
+        private readonly List<IDomainEvent> _domainEvents;
 
         #endregion Declarations
 
@@ -20,7 +18,7 @@ public class DomainEventStream<TAggregateRootId> : IDomainEventStream<TAggregate
         /// <summary>
         /// Id of the aggregate root which owns this stream.
         /// </summary>
-        public TAggregateRootId AggregateRootId { get; }
+        public Guid AggregateRootId { get; }
 
         /// <summary>
         /// Get number of domain events in the stream.
@@ -35,18 +33,18 @@ public class DomainEventStream<TAggregateRootId> : IDomainEventStream<TAggregate
         /// Constructor to create an empty stream for the aggregate.
         /// </summary>
         /// <param name="aggreggateRootId">ID of the aggregate root.</param>
-        public DomainEventStream(TAggregateRootId aggreggateRootId)
+        public DomainEventStream(Guid aggreggateRootId)
         {
             AggregateRootId = aggreggateRootId;
-            _domainEvents = new List<IDomainEvent<TAggregateRootId>>();
+            _domainEvents = new List<IDomainEvent>();
         }
 
         /// <summary>
         /// Constructs a new instance of a read-only stream.
         /// </summary>
         /// <param name="aggregateRootId">Id of the aggregate root which owns this stream.</param>
         /// <param name="domainEvents">Domain events.</param>
-        public DomainEventStream(TAggregateRootId aggregateRootId, IEnumerable<IDomainEvent<TAggregateRootId>> domainEvents)
+        public DomainEventStream(Guid aggregateRootId, IEnumerable<IDomainEvent> domainEvents)
         {
             if (domainEvents == null)
             {
@@ -66,7 +64,7 @@ public DomainEventStream(TAggregateRootId aggregateRootId, IEnumerable<IDomainEv
         /// </summary>
         /// <param name="domainEventToAppend">Domain event to append to the domain event stream.</param>
         /// <returns>New instance of domain event stream with the appended domain event.</returns>
-        public DomainEventStream<TAggregateRootId> AppendDomainEvent(IDomainEvent<TAggregateRootId> domainEventToAppend)
+        public DomainEventStream AppendDomainEvent(IDomainEvent domainEventToAppend)
         {
             if (domainEventToAppend == null)
             {
@@ -78,17 +76,17 @@ public DomainEventStream<TAggregateRootId> AppendDomainEvent(IDomainEvent<TAggre
                 throw new InvalidOperationException("Cannot append domain event belonging to a different aggregate root.");
             }
 
-            return AppendDomainEventStream(new DomainEventStream<TAggregateRootId>(AggregateRootId, new[] { domainEventToAppend }));
+            return new DomainEventStream(AggregateRootId, this.Concat(new[] { domainEventToAppend }));
         }
 
         /// <summary>
         /// Creates a new domain event stream which has the appended domain event stream.
         /// </summary>
         /// <param name="streamToAppend">Domain event stream to append to this domain event stream.</param>
         /// <returns>New instance of domain event stream with the appended domain event stream.</returns>
-        public DomainEventStream<TAggregateRootId> AppendDomainEventStream(IDomainEventStream<TAggregateRootId> streamToAppend)
+        public DomainEventStream AppendDomainEventStream(IDomainEventStream streamToAppend)
         {
-            if(streamToAppend == null)
+            if (streamToAppend == null)
             {
                 throw new ArgumentNullException(nameof(streamToAppend));
             }
@@ -98,16 +96,16 @@ public DomainEventStream<TAggregateRootId> AppendDomainEventStream(IDomainEventS
                 throw new InvalidOperationException("Cannot append domain events belonging to a different aggregate root.");
             }
 
-            return new DomainEventStream<TAggregateRootId>(AggregateRootId, this.Concat(streamToAppend));
+            return new DomainEventStream(AggregateRootId, this.Concat(streamToAppend));
         }
 
         /// <summary>
         /// Get enumerator.
         /// </summary>
         /// <returns>Enumerator which yields domain events until iterated upon.</returns>
-        public IEnumerator<IDomainEvent<TAggregateRootId>> GetEnumerator()
+        public IEnumerator<IDomainEvent> GetEnumerator()
         {
-            foreach(IDomainEvent<TAggregateRootId> domainEvent in _domainEvents)
+            foreach (IDomainEvent domainEvent in _domainEvents)
             {
                 yield return domainEvent;
             }
@@ -119,7 +117,7 @@ public IEnumerator<IDomainEvent<TAggregateRootId>> GetEnumerator()
         /// <returns>Enumerator which yields domain events until iterated upon.</returns>
         IEnumerator IEnumerable.GetEnumerator()
         {
-            foreach (IDomainEvent<TAggregateRootId> domainEvent in _domainEvents)
+            foreach (IDomainEvent domainEvent in _domainEvents)
             {
                 yield return domainEvent;
             }

Src/Xer.DomainDriven/Entity.cs

@@ -2,12 +2,12 @@
 
 namespace Xer.DomainDriven
 {
-    public abstract class Entity<TId> : IEntity<TId> where TId : IEquatable<TId>
+    public abstract class Entity : IEntity
     {
         /// <summary>
         /// Unique ID.
         /// </summary>
-        public TId Id { get; protected set; }
+        public Guid Id { get; protected set; }
 
         /// <summary>
         /// Date when entitity was created.
@@ -26,7 +26,7 @@ public abstract class Entity<TId> : IEntity<TId> where TId : IEquatable<TId>
         /// This will set <see cref="Entity.Created"/> and <see cref="Entity.Updated"/> properties to <see cref="DateTime.UtcNow"/>.
         /// </remarks>
         /// <param name="entityId">ID of entity.</param>
-        public Entity(TId entityId)
+        public Entity(Guid entityId)
         {
             Id = entityId;
             Created = DateTime.UtcNow;
@@ -39,7 +39,7 @@ public Entity(TId entityId)
         /// <param name="entityId">ID of entity.</param>
         /// <param name="created">Created date.</param>
         /// <param name="updated">Updated date.</param>
-        public Entity(TId entityId, DateTime created, DateTime updated)
+        public Entity(Guid entityId, DateTime created, DateTime updated)
         {
             Id = entityId;
             Created = created;

Src/Xer.DomainDriven/Exceptions/DomainEventNotAppliedException.cs

@@ -2,22 +2,22 @@
 
 namespace Xer.DomainDriven.Exceptions
 {
-    public class DomainEventNotAppliedException<TAggregateRootId> : Exception where TAggregateRootId : IEquatable<TAggregateRootId>
+    public class DomainEventNotAppliedException : Exception
     {
-        public TAggregateRootId AggregateRootId { get; }
-        public IDomainEvent<TAggregateRootId> DomainEvent { get; }
+        public Guid AggregateRootId { get; }
+        public IDomainEvent DomainEvent { get; }
 
-        public DomainEventNotAppliedException(IDomainEvent<TAggregateRootId> domainEvent) 
+        public DomainEventNotAppliedException(IDomainEvent domainEvent) 
             : this(domainEvent, string.Empty)
         {
         }
 
-        public DomainEventNotAppliedException(IDomainEvent<TAggregateRootId> domainEvent, string message) 
+        public DomainEventNotAppliedException(IDomainEvent domainEvent, string message) 
             : this(domainEvent, message, null)
         {
         }
 
-        public DomainEventNotAppliedException(IDomainEvent<TAggregateRootId> domainEvent, string message, Exception innerException) 
+        public DomainEventNotAppliedException(IDomainEvent domainEvent, string message, Exception innerException) 
             : base(message, innerException)
         {
             AggregateRootId = domainEvent.AggregateRootId;