Merge pull request #9 from XerProjects/release-2.0.0

Release 2.0.0

Author: joel-jeremy

GitVersion.yml

@@ -1,12 +1,206 @@
 using System;
+using System.Collections.Generic;
+using Xer.DomainDriven.Exceptions;
 
 namespace Xer.DomainDriven
 {
     public abstract class AggregateRoot<TId> : Entity<TId>, IAggregateRoot<TId> where TId : IEquatable<TId>
     {
-        public AggregateRoot(TId aggregateRootId) 
+        #region Declarations
+        
+        private readonly Queue<IDomainEvent<TId>> _uncommittedDomainEvents = new Queue<IDomainEvent<TId>>();
+        private readonly DomainEventApplierRegistration _domainEventApplierRegistration = new DomainEventApplierRegistration();
+
+        #endregion Declarations
+
+        #region Constructors
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="aggregateRootId">Id of aggregate root.</param>
+        public AggregateRoot(TId aggregateRootId)
             : base(aggregateRootId)
         {
         }
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <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)
+            : base(aggregateRootId, created, updated)
+        {
+        }
+
+        #endregion Constructors
+
+        #region IAggregateRoot implementation
+
+        // Note: These methods have been implemented explicitly to avoid cluttering public API.
+
+        /// <summary>
+        /// 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()
+        {
+            return new DomainEventStream<TId>(Id, _uncommittedDomainEvents);
+        }
+
+        // <summary>
+        // Clear all internally tracked domain events.
+        // </summary>
+        void IAggregateRoot<TId>.ClearUncommitedDomainEvents()
+        {
+            _uncommittedDomainEvents.Clear();
+        }
+
+        #endregion IAggregateRoot implementation
+
+        #region Protected Methods
+
+        /// <summary>
+        /// Register action to apply domain event.
+        /// </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>
+        {
+            _domainEventApplierRegistration.RegisterApplierFor<TDomainEvent>(domainEventApplier);
+        }
+
+        /// <summary>
+        /// Apply domain event to this entity 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>
+        {
+            if (domainEvent == null)
+            {
+                throw new ArgumentNullException(nameof(domainEvent));
+            }
+
+            // Invoke and track the event to save to event store.
+            InvokeDomainEventApplier(domainEvent);
+        }
+
+        #endregion Protected Methods
+
+        #region Functions
+
+        /// <summary>
+        /// Invoke the registered action to handle the domain event.
+        /// </summary>
+        /// <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>
+        {
+            Action<IDomainEvent<TId>> domainEventApplier = _domainEventApplierRegistration.GetApplierFor(domainEvent);
+            if (domainEventApplier == null)
+            {
+                throw new DomainEventNotAppliedException<TId>(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.");
+            }
+
+            try
+            {
+                domainEventApplier.Invoke(domainEvent);
+
+                // Update timestamp.
+                Updated = domainEvent.TimeStamp;
+                
+                if (markDomainEventForCommit)
+                {
+                    MarkAppliedDomainEventForCommit(domainEvent);
+                }
+            }
+            catch (Exception ex)
+            {
+                throw new DomainEventNotAppliedException<TId>(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
+
+        #region Domain Event Handler Registration
+
+        /// <summary>
+        /// Holds the actions to be executed in handling specific types of domain event.
+        /// </summary>
+        private class DomainEventApplierRegistration
+        {
+            private readonly IDictionary<Type, Action<IDomainEvent<TId>>> _applierByDomainEventType = new Dictionary<Type, Action<IDomainEvent<TId>>>();
+
+            /// <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>
+            {
+                if (applier == null)
+                {
+                    throw new ArgumentNullException(nameof(applier));
+                }
+
+                Type domainEventType = typeof(TDomainEvent);
+
+                if (_applierByDomainEventType.ContainsKey(domainEventType))
+                {
+                    throw new InvalidOperationException($"A domain event applier that applies {domainEventType.Name} has already been registered.");
+                }
+                
+                Action<IDomainEvent<TId>> domainEventApplier = (d) =>
+                {
+                    TDomainEvent domainEvent = d as TDomainEvent;
+                    if (domainEvent == null)
+                    {
+                        throw new ArgumentException(
+                            $@"An invalid domain event is given to the domain event applier. 
+                            Expected domain event is of type {typeof(TDomainEvent).Name} but {d.GetType().Name} was found.");
+                    }
+
+                    applier.Invoke(domainEvent);
+                };
+
+                _applierByDomainEventType.Add(domainEventType, domainEventApplier);
+            }
+
+            /// <summary>
+            /// 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)
+            {
+                if (domainEvent == null)
+                {
+                    throw new ArgumentNullException(nameof(domainEvent));
+                }
+
+                _applierByDomainEventType.TryGetValue(domainEvent.GetType(), out Action<IDomainEvent<TId>> domainEventAction);
+
+                return domainEventAction;
+            }
+        }
+
+        #endregion Domain Event Handler Registration
     }
 }

Src/Xer.DomainDriven/AggregateRoot.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Xer.DomainDriven
+{
+    public class DomainEventStream<TAggregateRootId> : IDomainEventStream<TAggregateRootId>, 
+                                                       IEnumerable<IDomainEvent<TAggregateRootId>> 
+                                                       where TAggregateRootId : IEquatable<TAggregateRootId>
+    {
+        #region Declarations
+        
+        private readonly ICollection<IDomainEvent<TAggregateRootId>> _domainEvents;
+
+        #endregion Declarations
+
+        #region Properties
+            
+        /// <summary>
+        /// Id of the aggregate root which owns this stream.
+        /// </summary>
+        public TAggregateRootId AggregateRootId { get; }
+
+        /// <summary>
+        /// Get number of domain events in the stream.
+        /// </summary>
+        public int DomainEventCount { get; }
+
+        #endregion Properties
+        
+        #region Constructors
+            
+        /// <summary>
+        /// Constructor to create an empty stream for the aggregate.
+        /// </summary>
+        /// <param name="aggreggateRootId">ID of the aggregate root.</param>
+        public DomainEventStream(TAggregateRootId aggreggateRootId)
+        {
+            AggregateRootId = aggreggateRootId;
+            _domainEvents = new List<IDomainEvent<TAggregateRootId>>();
+        }
+
+        /// <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)
+        {
+            if (domainEvents == null)
+            {
+                throw new ArgumentNullException(nameof(domainEvents));
+            }
+
+            _domainEvents = domainEvents.ToList();
+
+            AggregateRootId = aggregateRootId;
+            DomainEventCount = _domainEvents.Count;
+        }
+
+        #endregion Constructors
+
+        /// <summary>
+        /// Creates a new domain event stream which has the appended domain event.
+        /// </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)
+        {
+            if (domainEventToAppend == null)
+            {
+                throw new ArgumentNullException(nameof(domainEventToAppend));
+            }
+
+            if (!AggregateRootId.Equals(domainEventToAppend.AggregateRootId))
+            {
+                throw new InvalidOperationException("Cannot append domain event belonging to a different aggregate root.");
+            }
+
+            return AppendDomainEventStream(new DomainEventStream<TAggregateRootId>(AggregateRootId, 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)
+        {
+            if(streamToAppend == null)
+            {
+                throw new ArgumentNullException(nameof(streamToAppend));
+            }
+
+            if (!AggregateRootId.Equals(streamToAppend.AggregateRootId))
+            {
+                throw new InvalidOperationException("Cannot append domain events belonging to a different aggregate root.");
+            }
+            
+            return new DomainEventStream<TAggregateRootId>(AggregateRootId, this.Concat(streamToAppend));
+        }
+
+        /// <summary>
+        /// Get enumerator.
+        /// </summary>
+        /// <returns>Enumerator which yields domain events until iterated upon.</returns>
+        public IEnumerator<IDomainEvent<TAggregateRootId>> GetEnumerator()
+        {
+            foreach(IDomainEvent<TAggregateRootId> domainEvent in _domainEvents)
+            {
+                yield return domainEvent;
+            }
+        }
+
+        /// <summary>
+        /// Get enumerator.
+        /// </summary>
+        /// <returns>Enumerator which yields domain events until iterated upon.</returns>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            foreach (IDomainEvent<TAggregateRootId> domainEvent in _domainEvents)
+            {
+                yield return domainEvent;
+            }
+        }
+    }
+}

Src/Xer.DomainDriven/DomainEventStream.cs

@@ -22,12 +22,28 @@ public abstract class Entity<TId> : IEntity<TId> where TId : IEquatable<TId>
         /// <summary>
         /// Constructor.
         /// </summary>
+        /// <remarks>
+        /// 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)
         {
             Id = entityId;
-            Created = DateTime.Now;
-            Updated = DateTime.Now;
+            Created = DateTime.UtcNow;
+            Updated = DateTime.UtcNow;
+        }
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <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)
+        {
+            Id = entityId;
+            Created = created;
+            Updated = updated;
         }
     }
 }