Aggregate uses itself as IMemento to enable default snapshotting.

Author: andrey.leskov

GridDomain.Domain.Tests/GridDomain.Tests.csproj

@@ -236,6 +236,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Serialization\Aggregate_can_be_used_for_snapshotting_by_defaut.cs" />
     <Compile Include="Serialization\Domain_event_should_retain_createdTime_defaulted_in_constructor.cs" />
     <Compile Include="Serialization\Domain_event_should_retain_sagaId_and_createdTime.cs" />
     <Compile Include="Types_should_be_deserializable.cs" />

GridDomain.Domain.Tests/Serialization/Aggregate_can_be_used_for_snapshotting_by_defaut.cs

@@ -0,0 +1,75 @@
+using System;
+using CommonDomain;
+using GridDomain.EventSourcing;
+using GridDomain.EventSourcing.Sagas.FutureEvents;
+using NUnit.Framework;
+
+namespace GridDomain.Tests.Serialization
+{
+    [TestFixture]
+    class Aggregate_can_be_used_for_snapshotting_by_defaut
+    {
+        private TestAggregate _restoredAggregate;
+        private TestAggregate _aggregate;
+
+        class TestAggregate : Aggregate
+        {
+            public int Value { get; private set; }
+
+            public TestAggregate(int value, Guid id):base(id)
+            {
+               RaiseEvent(new TestAggregateCreatedEvent(id, value));
+            }
+
+            private void Apply(TestAggregateCreatedEvent e)
+            {
+                Id = e.SourceId;
+                Value = e.Value;
+            }
+
+            internal class TestAggregateCreatedEvent : DomainEvent
+            {
+                public int Value { get; }
+
+                public TestAggregateCreatedEvent(Guid id, int value) : base(id)
+                {
+                    Value = value;
+                }
+            }
+        }
+
+        [OneTimeSetUp]
+        public void Aggregate_by_default_can_be_saved_as_IMemento_for_snapshot()
+        {
+            _aggregate = new TestAggregate(1,Guid.NewGuid());
+            var snapshot = ((IAggregate)_aggregate).GetSnapshot();
+            var factory = new AggregateFactory();
+            _restoredAggregate = factory.Build<TestAggregate>(_aggregate.Id, snapshot);
+        }
+
+        [Test]
+        public void Ids_are_equal()
+        {
+            Assert.AreEqual(_aggregate.Id, _restoredAggregate.Id);
+        }
+
+        [Test]
+        public void Restored_aggregate_is_not_null()
+        {
+            Assert.NotNull(_restoredAggregate);
+        }
+
+        [Test]
+        public void Restored_aggregate_uncommitted_events_are_empty()
+        {
+            CollectionAssert.IsEmpty(((IAggregate)_restoredAggregate).GetUncommittedEvents());
+        }
+
+        [Test]
+        public void Restored_aggregate_state_is_equal_to_origin()
+        {
+            Assert.AreEqual(_aggregate.Value, _restoredAggregate.Value);
+        }
+    }
+
+}

GridDomain.EventSourcing.Sagas/FutureEvents/Aggregate.cs

@@ -8,7 +8,7 @@
 
 namespace GridDomain.EventSourcing.Sagas.FutureEvents
 {
-    public class Aggregate : AggregateBase
+    public class Aggregate : AggregateBase, IMemento
     {
         private static readonly AggregateFactory Factory = new AggregateFactory();
         public static T Empty<T>(Guid id) where T : IAggregate
@@ -117,5 +117,22 @@ private void DeleteFutureEvent(Guid futureEventId)
 
         #endregion
 
+        // Only for simple implementation 
+        Guid IMemento.Id
+        {
+            get { return Id; }
+            set { Id = value; }
+        }
+
+        int IMemento.Version
+        {
+            get { return Version; }
+            set { Version = value; }
+        }
+
+        protected override IMemento GetSnapshot()
+        {
+            return this;
+        }
     }
 }

GridDomain.EventSourcing/AggregateFactory.cs

@@ -17,9 +17,14 @@ public IAggregate Build(Type type, Guid id, IMemento snapshot)
             return snapshot == null ? Build(type, id) : BuildFromSnapshot(type, id, snapshot);
         }
 
+        //default convention: Aggregate is implementing IMemento itself
         protected virtual IAggregate BuildFromSnapshot(Type type, Guid id, IMemento snapshot)
         {
-            return Build(type, id);    
+            var aggregate = snapshot as IAggregate;
+            if (aggregate == null)
+                throw new InvalidDefaultMementoException(type, id, snapshot);
+            aggregate.ClearUncommittedEvents();
+            return aggregate;
         }
 
         public IAggregate Build(Type type, Guid id)

GridDomain.EventSourcing/GridDomain.EventSourcing.csproj

@@ -65,6 +65,7 @@
     <Compile Include="Adapters\IDomainEventAdapter.cs" />
     <Compile Include="Adapters\IEventAdapter.cs" />
     <Compile Include="Adapters\VersionedTypeSerializationBinder.cs" />
+    <Compile Include="InvalidDefaultMementoException.cs" />
     <Compile Include="ISourcedEvent.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Adapters\ObjectAdapter.cs" />

GridDomain.EventSourcing/InvalidDefaultMementoException.cs

@@ -0,0 +1,18 @@
+using System;
+using CommonDomain;
+
+namespace GridDomain.EventSourcing
+{
+    public class InvalidDefaultMementoException : Exception
+    {
+        public IMemento Snapshot { get; set; }
+        public Type Type { get; set; }
+        public Guid Id { get; set; }
+
+        public InvalidDefaultMementoException(Type type, Guid id, IMemento snapshot)
+            :base("Aggregate cannot be constructed from snapshot by default convention, memento is not IAggregate")
+        {
+            Snapshot = snapshot;
+        }
+    }
+}