From 90eff700b895ca660394bb7d4738e954ece567c2 Mon Sep 17 00:00:00 2001
From: Bill Biwer <bill.biwer@young-america.com>
Date: Mon, 18 May 2015 14:01:53 -0500
Subject: [PATCH 1/6] Added non-generic IAggregateRepository and
 implementations

---
 .../EventStoreAggregateRepository.cs          | 241 ++++++++++++-
 .../InMemoryAggregateRepository.cs            |  34 +-
 .../InMemoryJsonAggregateRepository.cs        |  39 ++-
 .../MementoBasedAggregateRepository.cs        |  63 ++++
 .../SqlServerAggregateRepository.cs           | 316 ++++++++++++++++--
 .../LogicalTypeRegistryBuilder.cs             |   1 +
 .../Domain/AggregateRepositoryTests.cs        | 190 +++++++++++
 .../EventStoreAggregateRepositoryTests.cs     |  20 +-
 .../InMemoryAggregateRepositoryTests.cs       |  15 +-
 .../InMemoryJsonAggregateRepositoryTests.cs   |  35 +-
 .../SqlServerAggregateRepositoryTests.cs      |  28 +-
 .../Modeling/Domain/Aggregate.cs              |  35 +-
 .../Domain/AggregateEventsLoadFrame.cs        |  11 +
 .../Domain/AggregateEventsSaveFrame.cs        |  15 +
 .../Modeling/Domain/AggregateLoadFrame.cs     |  12 +
 .../Modeling/Domain/AggregateMemento.cs       |  24 ++
 .../Modeling/Domain/AggregateRepository.cs    | 144 +++++++-
 .../Modeling/Domain/AggregateSaveFrame.cs     |  14 +
 .../Modeling/Domain/AggregateSnapshot.cs      |   3 +-
 .../Domain/AggregateSnapshotLoadFrame.cs      |  11 +
 .../Domain/AggregateSnapshotSaveFrame.cs      |  11 +
 .../Modeling/Domain/IAggregate.cs             |  11 +
 .../Modeling/Domain/IAggregateRepository.cs   |   7 +
 .../Modeling/Domain/IAggregateSnapshot.cs     |  11 +-
 .../Modeling/Domain/IScalarValue.cs           |   2 +
 25 files changed, 1216 insertions(+), 77 deletions(-)

diff --git a/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs b/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs
index 918b370..571ea82 100644
--- a/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs
@@ -21,23 +21,254 @@
 // THE SOFTWARE.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
-
 using EventStore.ClientAPI;
 using EventStore.ClientAPI.Exceptions;
-using Newtonsoft.Json;
 using iSynaptic.Commons;
-using iSynaptic.Commons.Collections.Generic;
 using iSynaptic.Commons.Linq;
-using iSynaptic.Modeling;
 using iSynaptic.Modeling.Domain;
 using iSynaptic.Serialization;
+using Newtonsoft.Json;
 
 namespace iSynaptic.Core.Persistence
 {
+    public class EventStoreAggregateRepository : AggregateRepository
+    {
+        private static readonly Guid _offsetEventId = new Guid(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
+        private static readonly EventData _offsetEvent = new EventData(_offsetEventId, "streamOffset", true, Encoding.Default.GetBytes("{}"), null);
+
+        private readonly ILogicalTypeRegistry _logicalTypeRegistry;
+
+        private readonly JsonSerializer _dataSerializer;
+        private readonly JsonSerializer _metadataSerializer;
+
+        private readonly Func<IEventStoreConnection> _connectionFactory;
+
+        public EventStoreAggregateRepository(ILogicalTypeRegistry logicalTypeRegistry, Func<IEventStoreConnection> connectionFactory)
+        {
+            _logicalTypeRegistry = Guard.NotNull(logicalTypeRegistry, "logicalTypeRegistry");
+            _connectionFactory = Guard.NotNull(connectionFactory, "connectionFactory");
+
+            _dataSerializer = JsonSerializerBuilder.Build(logicalTypeRegistry);
+
+            var metadataSerializerSettings = JsonSerializerBuilder.BuildSettings(logicalTypeRegistry);
+            metadataSerializerSettings.TypeNameHandling = TypeNameHandling.None;
+
+            _metadataSerializer = JsonSerializer.Create(metadataSerializerSettings);
+        }
+
+        protected override async Task<AggregateEventsLoadFrame> GetEvents(object id, int minVersion, int maxVersion)
+        {
+            var maxCount = (maxVersion - minVersion) + 1;
+
+            if (maxCount <= 0)
+                return null;
+
+            using (var cn = _connectionFactory())
+            {
+                await cn.ConnectAsync().ConfigureAwait(false);
+
+                String streamId = BuildStreamIdentifier(id);
+
+                var metadataResult = await cn.GetStreamMetadataAsync(streamId).ConfigureAwait(false);
+                if (metadataResult.MetastreamVersion == ExpectedVersion.NoStream)
+                    return null;
+
+                string aggregateTypeString;
+
+                if (!metadataResult.StreamMetadata.TryGetValue("aggregateType", out aggregateTypeString))
+                {
+                    throw new InvalidOperationException("Aggregate type is not specified in event stream metadata.");
+                }
+
+                var resolvedEvents = (await cn.ReadStreamEventsForwardAsync(streamId, minVersion, maxCount, false).ConfigureAwait(false))
+                    .ToMaybe()
+                    .Where(x => x.Status == SliceReadStatus.Success)
+                    .SelectMany(x => x.Events)
+                    .ToArray();
+
+                if (resolvedEvents.Length > 0)
+                {
+                    Type aggregateType = _logicalTypeRegistry.LookupActualType(LogicalType.Parse(aggregateTypeString));
+
+                    var events = resolvedEvents
+                        .Select(x => x.Event.Data)
+                        .Select(Encoding.Default.GetString)
+                        .Select(x => _dataSerializer.Deserialize<IAggregateEvent>(x));
+
+                    return new AggregateEventsLoadFrame(aggregateType, id, events);
+                }
+
+                return null;
+            }
+        }
+
+        protected async override Task SaveEvents(AggregateEventsSaveFrame frame)
+        {
+            var aggregateType = frame.AggregateType;
+            var id = frame.Id;
+            var evts = frame.Events.ToArray();
+
+            if (evts.Length <= 0)
+                throw new ArgumentException("There are no events to save.", "frame");
+
+            String streamId = BuildStreamIdentifier(id);
+            using (var cn = _connectionFactory())
+            {
+                await cn.ConnectAsync().ConfigureAwait(false);
+
+                bool isNewStream = evts[0].Version == 1;
+
+                try
+                {
+                    var events = evts.Select(e => BuildEventData(e.EventId, e, aggregateType));
+
+                    if (isNewStream)
+                    {
+                        var metadata = BuildStreamMetadata(aggregateType);
+                        await cn.SetStreamMetadataAsync(streamId, ExpectedVersion.NoStream, metadata).ConfigureAwait(false);
+
+                        events = new[] { _offsetEvent }.Concat(events);
+                    }
+
+                    int expectedVersion = isNewStream
+                        ? ExpectedVersion.EmptyStream
+                        : evts[0].Version - 1;
+
+                    await cn.AppendToStreamAsync(
+                        streamId,
+                        expectedVersion,
+                        events).ConfigureAwait(false);
+
+                }
+                catch (WrongExpectedVersionException ex)
+                {
+                    throw new AggregateConcurrencyException(ex);
+                }
+            }
+        }
+
+        protected override async Task<AggregateSnapshotLoadFrame> GetSnapshot(object id, int maxVersion)
+        {
+            using (var cn = _connectionFactory())
+            {
+                await cn.ConnectAsync().ConfigureAwait(false);
+
+                String snapshotStreamId = BuildSnapshotStreamIdentifier(id);
+
+                var metadataResult = await cn.GetStreamMetadataAsync(snapshotStreamId).ConfigureAwait(false);
+                if (metadataResult.MetastreamVersion == ExpectedVersion.NoStream)
+                    return null;
+
+                string aggregateTypeString;
+
+                if (!metadataResult.StreamMetadata.TryGetValue("aggregateType", out aggregateTypeString))
+                {
+                    throw new InvalidOperationException("Aggregate type is not specified in event stream metadata.");
+                }
+
+                var resolvedEvent = (await cn.ReadStreamEventsForwardAsync(snapshotStreamId, 0, int.MaxValue, false).ConfigureAwait(false))
+                    .ToMaybe()
+                    .Where(x => x.Status == SliceReadStatus.Success)
+                    .SelectMany(x => x.Events)
+                    .TrySingle();
+
+                var snapshot = resolvedEvent
+                    .Select(x => x.Event.Data)
+                    .Select(Encoding.Default.GetString)
+                    .Select(x => _dataSerializer.Deserialize<IAggregateSnapshot>(x))
+                    .Where(x => x.Version <= maxVersion);
+
+                if (snapshot.HasValue)
+                {
+                    Type aggregateType = _logicalTypeRegistry.LookupActualType(LogicalType.Parse(aggregateTypeString));
+
+                    return new AggregateSnapshotLoadFrame(aggregateType, id, snapshot.Value);
+                }
+
+                return null;
+            }
+        }
+
+        protected async override Task SaveSnapshot(AggregateSnapshotSaveFrame frame)
+        {
+            using (var cn = _connectionFactory())
+            {
+                await cn.ConnectAsync().ConfigureAwait(false);
+
+                var aggregateType = frame.AggregateType;
+                var id = frame.Id;
+                var snapshot = frame.Snapshot;
+
+                String streamId = BuildSnapshotStreamIdentifier(id);
+
+                var metadata = BuildSnapshotStreamMetadata(aggregateType);
+
+                var stream = await cn.ReadStreamEventsForwardAsync(streamId, 0, int.MaxValue, false).ConfigureAwait(false);
+                if (stream.Status == SliceReadStatus.StreamNotFound)
+                {
+                    await cn.SetStreamMetadataAsync(streamId, ExpectedVersion.NoStream, metadata).ConfigureAwait(false);
+
+                    await cn.AppendToStreamAsync(
+                        streamId,
+                        ExpectedVersion.EmptyStream,
+                        BuildEventData(
+                            snapshot.SnapshotId,
+                            snapshot,
+                            aggregateType)
+                        ).ConfigureAwait(false);
+                }
+                else
+                {
+                    await cn.AppendToStreamAsync(
+                        streamId,
+                        stream.LastEventNumber,
+                        BuildEventData(
+                            snapshot.SnapshotId,
+                            snapshot,
+                            aggregateType)
+                    ).ConfigureAwait(false);
+                }
+            }
+        }
+
+        private StreamMetadata BuildSnapshotStreamMetadata(Type aggregateType)
+        {
+            return StreamMetadata.Build()
+                .SetMaxCount(1)
+                .SetCustomProperty("aggregateType", _logicalTypeRegistry.LookupLogicalType(aggregateType).ToString())
+                .Build();
+        }
+
+        private StreamMetadata BuildStreamMetadata(Type aggregateType)
+        {
+            return StreamMetadata.Build()
+                .SetCustomProperty("aggregateType", _logicalTypeRegistry.LookupLogicalType(aggregateType).ToString())
+                .Build();
+        }
+
+        protected EventData BuildEventData(Guid id, object data, Type aggregateType)
+        {
+            return new EventData(id,
+                _logicalTypeRegistry.LookupLogicalType(data.GetType()).ToString(),
+                true,
+                Encoding.Default.GetBytes(_dataSerializer.Serialize(data)),
+                null);
+        }
+
+        protected virtual String BuildStreamIdentifier(object id)
+        {
+            return _dataSerializer.Serialize(id);
+        }
+
+        protected virtual String BuildSnapshotStreamIdentifier(object id)
+        {
+            return String.Format("{0}-snapshot", BuildStreamIdentifier(id));
+        }
+    }
+
     public class EventStoreAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
         where TAggregate : class, IAggregate<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
diff --git a/src/iSynaptic.Core.Persistence/InMemoryAggregateRepository.cs b/src/iSynaptic.Core.Persistence/InMemoryAggregateRepository.cs
index 4d1b07b..e6e89ed 100644
--- a/src/iSynaptic.Core.Persistence/InMemoryAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/InMemoryAggregateRepository.cs
@@ -27,10 +27,42 @@
 using iSynaptic.Commons;
 using iSynaptic.Commons.Collections.Generic;
 using iSynaptic.Modeling.Domain;
-using iSynaptic.Serialization;
 
 namespace iSynaptic.Core.Persistence
 {
+    public class InMemoryAggregateRepository : MementoBasedAggregateRepository
+    {
+        private readonly Dictionary<object, AggregateMemento> _state =
+            new Dictionary<object, AggregateMemento>();
+
+        protected override Task<Maybe<AggregateMemento>> TryLoadMemento(object id)
+        {
+            lock (_state)
+            {
+                return Task.FromResult(_state.TryGetValue(id));
+            }
+        }
+
+        protected override async Task StoreMemento(Func<Task<KeyValuePair<object, AggregateMemento>>> mementoFactory)
+        {
+            bool lockTaken = false;
+
+            try
+            {
+                Monitor.Enter(_state, ref lockTaken);
+
+                var memento = await mementoFactory();
+                _state[memento.Key] = memento.Value;
+
+            }
+            finally
+            {
+                if (lockTaken)
+                    Monitor.Exit(_state);
+            }
+        }
+    }
+
     public class InMemoryAggregateRepository<TAggregate, TIdentifier> : MementoBasedAggregateRepository<TAggregate, TIdentifier>
         where TAggregate : class, IAggregate<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
diff --git a/src/iSynaptic.Core.Persistence/InMemoryJsonAggregateRepository.cs b/src/iSynaptic.Core.Persistence/InMemoryJsonAggregateRepository.cs
index 3dacd07..d312f14 100644
--- a/src/iSynaptic.Core.Persistence/InMemoryJsonAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/InMemoryJsonAggregateRepository.cs
@@ -27,12 +27,47 @@
 using Newtonsoft.Json;
 using iSynaptic.Commons;
 using iSynaptic.Commons.Collections.Generic;
-using iSynaptic.Modeling;
 using iSynaptic.Modeling.Domain;
 using iSynaptic.Serialization;
 
 namespace iSynaptic.Core.Persistence
 {
+    public class InMemoryJsonAggregateRepository : MementoBasedAggregateRepository
+    {
+        private readonly Dictionary<String, String> _state =
+            new Dictionary<String, String>();
+
+        private readonly JsonSerializer _serializer;
+
+        public InMemoryJsonAggregateRepository(JsonSerializer serializer)
+        {
+            _serializer = Guard.NotNull(serializer, "serializer");
+        }
+
+        protected override Task<Maybe<AggregateMemento>> TryLoadMemento(object id)
+        {
+            return Task.FromResult(_state.TryGetValue(_serializer.Serialize(id))
+                       .Select(json => _serializer.Deserialize<AggregateMemento>(json)));
+        }
+
+        protected override async Task StoreMemento(Func<Task<KeyValuePair<object, AggregateMemento>>> mementoFactory)
+        {
+            bool lockTaken = false;
+            try
+            {
+                Monitor.Enter(_state, ref lockTaken);
+
+                var memento = await mementoFactory();
+                _state[_serializer.Serialize(memento.Key)] = _serializer.Serialize(memento.Value);
+            }
+            finally
+            {
+                if (lockTaken)
+                    Monitor.Exit(_state);
+            }
+        }
+    }
+
     public class InMemoryJsonAggregateRepository<TAggregate, TIdentifier> : MementoBasedAggregateRepository<TAggregate, TIdentifier>
         where TAggregate : class, IAggregate<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
@@ -70,4 +105,4 @@ protected override async Task StoreMemento(Func<Task<KeyValuePair<TIdentifier, A
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/iSynaptic.Core.Persistence/MementoBasedAggregateRepository.cs b/src/iSynaptic.Core.Persistence/MementoBasedAggregateRepository.cs
index a772b7e..dffee48 100644
--- a/src/iSynaptic.Core.Persistence/MementoBasedAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/MementoBasedAggregateRepository.cs
@@ -31,6 +31,69 @@
 
 namespace iSynaptic.Core.Persistence
 {
+    public abstract class MementoBasedAggregateRepository : AggregateRepository
+    {
+        protected abstract Task<Maybe<AggregateMemento>> TryLoadMemento(object id);
+        protected abstract Task StoreMemento(Func<Task<KeyValuePair<object, AggregateMemento>>> mementoFactory);
+
+        protected override async Task<AggregateSnapshotLoadFrame> GetSnapshot(object id, int maxVersion)
+        {
+            return (await TryLoadMemento(id))
+                .Where(x => x.Snapshot.Select(y => y.Version <= maxVersion).ValueOrDefault())
+                .Select(x => new AggregateSnapshotLoadFrame(x.AggregateType, id, x.Snapshot.Value))
+                .ValueOrDefault();
+        }
+
+        protected override async Task<AggregateEventsLoadFrame> GetEvents(object id, int minVersion, int maxVersion)
+        {
+            return (await TryLoadMemento(id))
+                .Select(x => new AggregateEventsLoadFrame(
+                                 x.AggregateType,
+                                 id,
+                                 x.Events
+                                  .SkipWhile(y => y.Version < minVersion)
+                                  .TakeWhile(y => y.Version <= maxVersion)))
+                .ValueOrDefault();
+        }
+
+        protected override Task SaveSnapshot(AggregateSnapshotSaveFrame frame)
+        {
+            return StoreMemento(async () =>
+            {
+                var aggregateType = frame.AggregateType;
+                var snapshot = frame.Snapshot;
+
+                var state = (await TryLoadMemento(snapshot.Id)).ValueOrDefault();
+
+                return KeyValuePair.Create(snapshot.Id, new AggregateMemento(aggregateType, snapshot.ToMaybe(), state != null ? state.Events : null));
+            });
+        }
+
+        protected override Task SaveEvents(AggregateEventsSaveFrame frame)
+        {
+            var aggregateType = frame.AggregateType;
+            var id = frame.Id;
+            var events = frame.Events.ToArray();
+
+            return StoreMemento(async () =>
+                KeyValuePair.Create(id, (await TryLoadMemento(id))
+                    .Select(x =>
+                    {
+                        var lastEvent = x.Events.TryLast();
+                        var actualVersion = lastEvent.Select(y => y.Version).ValueOrDefault();
+
+                        if (actualVersion != frame.ExpectedVersion)
+                            throw new AggregateConcurrencyException();
+
+                        return new AggregateMemento(
+                            aggregateType,
+                            x.Snapshot,
+                            x.Events.Concat(events.SkipWhile(y => y.Version <= lastEvent.Select(z => z.Version).ValueOrDefault())));
+                    })
+                    .ValueOrDefault(() => new AggregateMemento(aggregateType, Maybe<IAggregateSnapshot>.NoValue, events))));
+        }
+    }
+
     public abstract class MementoBasedAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
         where TAggregate : class, IAggregate<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
diff --git a/src/iSynaptic.Core.Persistence/SqlServerAggregateRepository.cs b/src/iSynaptic.Core.Persistence/SqlServerAggregateRepository.cs
index 2356559..8d1380f 100644
--- a/src/iSynaptic.Core.Persistence/SqlServerAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/SqlServerAggregateRepository.cs
@@ -36,7 +36,7 @@
 
 namespace iSynaptic.Core.Persistence
 {
-    public static class SqlServerAggregateRepository
+    public class SqlServerAggregateRepository : AggregateRepository
     {
         private static readonly Regex _scriptRegex = new Regex(@"(?<script>.+?)(\r\nGO(\r\n|$))", 
             RegexOptions.ExplicitCapture | RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline);
@@ -68,15 +68,10 @@ public static async Task EnsureTablesExist(string connectionString)
                 }
             }
         }
-    }
 
-    public class SqlServerAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
-        where TAggregate : class, IAggregate<TIdentifier> 
-        where TIdentifier : IEquatable<TIdentifier>
-    {
         #region Helper Classes
 
-        private abstract class DbRow
+        internal abstract class DbRow
         {
             private string _aggregateId;
             private int _version;
@@ -91,8 +86,8 @@ protected DbRow(string aggregateId, int version, string type)
 
             private string ValidateAggregateId(string value, string argumentName)
             {
-                if(value == null) throw new ArgumentNullException(argumentName);
-                if(value.Length > 200) throw new ArgumentException("Aggregate ID must be 200 characters or less.", argumentName);
+                if (value == null) throw new ArgumentNullException(argumentName);
+                if (value.Length > 200) throw new ArgumentException("Aggregate ID must be 200 characters or less.", argumentName);
 
                 return value;
             }
@@ -122,8 +117,8 @@ public int Version
             {
                 get { return _version; }
                 set { _version = ValidateVersion(value, "value"); }
-            }  
-          
+            }
+
             public string Type
             {
                 get { return _type; }
@@ -131,7 +126,7 @@ public string Type
             }
         }
 
-        private abstract class DbDataRow : DbRow
+        internal abstract class DbDataRow : DbRow
         {
             private string _data;
 
@@ -143,8 +138,8 @@ protected DbDataRow(string aggregateId, int version, string type, string data)
 
             private string ValidateData(string data, string argumentName)
             {
-                if(data == null) throw new ArgumentNullException(argumentName);
-                if(string.IsNullOrWhiteSpace(data)) throw new ArgumentException("Data cannot be only whitespace.", argumentName);
+                if (data == null) throw new ArgumentNullException(argumentName);
+                if (string.IsNullOrWhiteSpace(data)) throw new ArgumentException("Data cannot be only whitespace.", argumentName);
 
                 return data;
             }
@@ -156,15 +151,15 @@ public string Data
             }
         }
 
-        private class DbAggregate : DbRow
+        internal class DbAggregate : DbRow
         {
-            public DbAggregate(string aggregateId, int version, string type) 
+            public DbAggregate(string aggregateId, int version, string type)
                 : base(aggregateId, version, type)
             {
             }
         }
 
-        private class DbAggregateEvent : DbDataRow
+        internal class DbAggregateEvent : DbDataRow
         {
             public DbAggregateEvent(string aggregateId, int version, string type, string data)
                 : base(aggregateId, version, type, data)
@@ -172,9 +167,9 @@ public DbAggregateEvent(string aggregateId, int version, string type, string dat
             }
         }
 
-        private class DbAggregateSnapshot : DbDataRow
+        internal class DbAggregateSnapshot : DbDataRow
         {
-            public DbAggregateSnapshot(string aggregateId, int version, string type, string data) 
+            public DbAggregateSnapshot(string aggregateId, int version, string type, string data)
                 : base(aggregateId, version, type, data)
             {
             }
@@ -195,7 +190,7 @@ public SqlServerAggregateRepository(ILogicalTypeRegistry logicalTypeRegistry, st
             _connectionString = Guard.NotNullOrWhiteSpace(connectionString, "connectionString");
         }
 
-        protected override async Task<AggregateSnapshotLoadFrame<TIdentifier>> GetSnapshot(TIdentifier id, int maxVersion)
+        protected override async Task<AggregateSnapshotLoadFrame> GetSnapshot(object id, int maxVersion)
         {
             string idString = ConvertIdentifierToString(id);
 
@@ -229,8 +224,8 @@ ORDER BY Version DESC"
                         {
                             string data = reader.GetString(reader.GetOrdinal("Data"));
 
-                            var snapshot = _dataSerializer.Deserialize<IAggregateSnapshot<TIdentifier>>(data);
-                            return new AggregateSnapshotLoadFrame<TIdentifier>(aggregateType, id, snapshot);
+                            var snapshot = _dataSerializer.Deserialize<IAggregateSnapshot>(data);
+                            return new AggregateSnapshotLoadFrame(aggregateType, id, snapshot);
                         }
                     }
                 }
@@ -239,10 +234,10 @@ ORDER BY Version DESC"
             }
         }
 
-        protected override async Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(TIdentifier id, int minVersion, int maxVersion)
+        protected override async Task<AggregateEventsLoadFrame> GetEvents(object id, int minVersion, int maxVersion)
         {
             string idString = ConvertIdentifierToString(id);
-            
+
             using (var connection = new SqlConnection(_connectionString))
             {
                 await connection.OpenAsync();
@@ -256,11 +251,11 @@ protected override async Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(T
                         LogicalType.Parse(dbAggregate.Type));
 
                     var events = dbEvents
-                        .Select(x => _dataSerializer.Deserialize<IAggregateEvent<TIdentifier>>(x))
+                        .Select(x => _dataSerializer.Deserialize<IAggregateEvent>(x))
                         .ToArray();
 
-                    return events.Length > 0 
-                        ? new AggregateEventsLoadFrame<TIdentifier>(aggregateType, id, events) 
+                    return events.Length > 0
+                        ? new AggregateEventsLoadFrame(aggregateType, id, events)
                         : null;
                 }
 
@@ -268,7 +263,7 @@ protected override async Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(T
             }
         }
 
-        protected override async Task SaveSnapshot(AggregateSnapshotSaveFrame<TIdentifier> frame)
+        protected override async Task SaveSnapshot(AggregateSnapshotSaveFrame frame)
         {
             string idString = ConvertIdentifierToString(frame.Id);
             string type = _logicalTypeRegistry.LookupLogicalType(frame.Snapshot.GetType()).ToString();
@@ -313,7 +308,7 @@ protected override async Task SaveSnapshot(AggregateSnapshotSaveFrame<TIdentifie
             }
         }
 
-        protected override async Task SaveEvents(AggregateEventsSaveFrame<TIdentifier> frame)
+        protected override async Task SaveEvents(AggregateEventsSaveFrame frame)
         {
             string idString = ConvertIdentifierToString(frame.Id);
             string type = _logicalTypeRegistry.LookupLogicalType(frame.AggregateType).ToString();
@@ -336,7 +331,7 @@ protected override async Task SaveEvents(AggregateEventsSaveFrame<TIdentifier> f
             }
         }
 
-        private static async Task UpsertAggregate(SqlConnection connection, SqlTransaction transaction, string idString, int expectedVersion, int newVersion, string type)
+        internal static async Task UpsertAggregate(SqlConnection connection, SqlTransaction transaction, string idString, int expectedVersion, int newVersion, string type)
         {
             bool isNewAggregate = expectedVersion == 0;
             if (isNewAggregate)
@@ -364,8 +359,7 @@ private static async Task UpsertAggregate(SqlConnection connection, SqlTransacti
             }
         }
 
-        private static async Task InsertAggregate(SqlConnection connection, SqlTransaction transaction, string idString,
-                                                  int newVersion, string type)
+        internal static async Task InsertAggregate(SqlConnection connection, SqlTransaction transaction, string idString, int newVersion, string type)
         {
             var insertCommand = new SqlCommand
             {
@@ -385,7 +379,7 @@ private static async Task InsertAggregate(SqlConnection connection, SqlTransacti
                 throw new AggregateConcurrencyException();
         }
 
-        private async Task InsertEvents(IEnumerable<IAggregateEvent<TIdentifier>> events, string idString, SqlConnection connection, SqlTransaction transaction)
+        private async Task InsertEvents(IEnumerable<IAggregateEvent> events, string idString, SqlConnection connection, SqlTransaction transaction)
         {
             var dbEvents = events.Select(x => new DbAggregateEvent(idString,
                                                                    x.Version,
@@ -474,10 +468,264 @@ FROM AggregateEvents
             return results.ToArray();
         }
 
+        protected virtual string ConvertIdentifierToString(object id)
+        {
+            Guard.NotNull(id, "id");
+            return _dataSerializer.Serialize(id);
+        }
+    }
+
+    public class SqlServerAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
+        where TAggregate : class, IAggregate<TIdentifier> 
+        where TIdentifier : IEquatable<TIdentifier>
+    {
+        private readonly ILogicalTypeRegistry _logicalTypeRegistry;
+        private readonly JsonSerializer _dataSerializer;
+
+        private readonly string _connectionString;
+
+        public SqlServerAggregateRepository(ILogicalTypeRegistry logicalTypeRegistry, string connectionString)
+        {
+            _logicalTypeRegistry = Guard.NotNull(logicalTypeRegistry, "logicalTypeRegistry");
+            _dataSerializer = JsonSerializerBuilder.Build(logicalTypeRegistry);
+
+            _connectionString = Guard.NotNullOrWhiteSpace(connectionString, "connectionString");
+        }
+
+        protected override async Task<AggregateSnapshotLoadFrame<TIdentifier>> GetSnapshot(TIdentifier id, int maxVersion)
+        {
+            string idString = ConvertIdentifierToString(id);
+
+            using (var connection = new SqlConnection(_connectionString))
+            {
+                await connection.OpenAsync();
+
+                var dbAggregate = await GetAggregate(idString, connection);
+                if (dbAggregate != null)
+                {
+                    Type aggregateType = _logicalTypeRegistry.LookupActualType(
+                        LogicalType.Parse(dbAggregate.Type));
+
+                    var command = new SqlCommand
+                    {
+                        Connection = connection,
+                        CommandType = CommandType.Text,
+                        CommandText = @"SELECT TOP 1 Data
+                                          FROM AggregateSnapshots
+                                         WHERE AggregateId = @pAggregateId 
+                                           AND Version <= @pMaxVersion
+                                      ORDER BY Version DESC"
+                    };
+
+                    command.Parameters.AddWithValue("pAggregateId", idString);
+                    command.Parameters.AddWithValue("pMaxVersion", maxVersion);
+
+                    using (var reader = await command.ExecuteReaderAsync(CommandBehavior.SingleRow))
+                    {
+                        if (await reader.ReadAsync())
+                        {
+                            string data = reader.GetString(reader.GetOrdinal("Data"));
+
+                            var snapshot = _dataSerializer.Deserialize<IAggregateSnapshot<TIdentifier>>(data);
+                            return new AggregateSnapshotLoadFrame<TIdentifier>(aggregateType, id, snapshot);
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+
+        protected override async Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(TIdentifier id, int minVersion, int maxVersion)
+        {
+            string idString = ConvertIdentifierToString(id);
+            
+            using (var connection = new SqlConnection(_connectionString))
+            {
+                await connection.OpenAsync();
+                var dbAggregate = await GetAggregate(idString, connection);
+
+                if (dbAggregate != null)
+                {
+                    var dbEvents = await GetAggregateEvents(idString, minVersion, maxVersion, connection);
+
+                    Type aggregateType = _logicalTypeRegistry.LookupActualType(
+                        LogicalType.Parse(dbAggregate.Type));
+
+                    var events = dbEvents
+                        .Select(x => _dataSerializer.Deserialize<IAggregateEvent<TIdentifier>>(x))
+                        .ToArray();
+
+                    return events.Length > 0 
+                        ? new AggregateEventsLoadFrame<TIdentifier>(aggregateType, id, events) 
+                        : null;
+                }
+
+                return null;
+            }
+        }
+
+        protected override async Task SaveSnapshot(AggregateSnapshotSaveFrame<TIdentifier> frame)
+        {
+            string idString = ConvertIdentifierToString(frame.Id);
+            string type = _logicalTypeRegistry.LookupLogicalType(frame.Snapshot.GetType()).ToString();
+
+            using (var connection = new SqlConnection(_connectionString))
+            {
+                await connection.OpenAsync();
+
+                using (var transaction = connection.BeginTransaction())
+                {
+                    if (frame.IsNew)
+                        await SqlServerAggregateRepository.InsertAggregate(connection, transaction, idString, frame.Snapshot.Version, type);
+
+                    var command = new SqlCommand
+                    {
+                        Connection = connection,
+                        Transaction = transaction,
+                        CommandType = CommandType.Text,
+                        CommandText = @"INSERT INTO AggregateSnapshots (AggregateId, Version, Type, Data) VALUES (@pAggregateId, @pVersion, @pType, @pData)"
+                    };
+
+                    command.Parameters.AddWithValue("pAggregateId", idString);
+                    command.Parameters.AddWithValue("pVersion", frame.Snapshot.Version);
+                    command.Parameters.AddWithValue("pType", type);
+                    command.Parameters.AddWithValue("pData", _dataSerializer.Serialize(frame.Snapshot));
+
+                    try
+                    {
+                        int recordsAffected = await command.ExecuteNonQueryAsync();
+                        if (recordsAffected != 1)
+                            throw new AggregateConcurrencyException();
+                    }
+                    catch (SqlException sqlEx)
+                    {
+                        // catch primary key constraint violations - saving snapshot is idempotent
+                        if (sqlEx.Number != 2627)
+                            throw;
+                    }
+
+                    transaction.Commit();
+                }
+            }
+        }
+
+        protected override async Task SaveEvents(AggregateEventsSaveFrame<TIdentifier> frame)
+        {
+            string idString = ConvertIdentifierToString(frame.Id);
+            string type = _logicalTypeRegistry.LookupLogicalType(frame.AggregateType).ToString();
+            var events = frame.Events.ToArray();
+
+            if (events.Length <= 0)
+                throw new ArgumentException("There are no events to save.", "frame");
+
+            using (var connection = new SqlConnection(_connectionString))
+            {
+                await connection.OpenAsync();
+
+                using (var transaction = connection.BeginTransaction(IsolationLevel.Serializable))
+                {
+                    await SqlServerAggregateRepository.UpsertAggregate(connection, transaction, idString, events[0].Version - 1, events[events.Length - 1].Version, type);
+                    await InsertEvents(events, idString, connection, transaction);
+
+                    transaction.Commit();
+                }
+            }
+        }
+
+        private async Task InsertEvents(IEnumerable<IAggregateEvent<TIdentifier>> events, string idString, SqlConnection connection, SqlTransaction transaction)
+        {
+            var dbEvents = events.Select(x => new SqlServerAggregateRepository.DbAggregateEvent(idString,
+                                                                   x.Version,
+                                                                   _logicalTypeRegistry.LookupLogicalType(x.GetType()).ToString(),
+                                                                   _dataSerializer.Serialize(x)))
+                .ToArray();
+
+            foreach (var dbEvent in dbEvents)
+            {
+                int recordsAffected = await InsertEvent(connection, transaction, dbEvent);
+                if (recordsAffected != 1)
+                    throw new AggregateConcurrencyException();
+            }
+        }
+
+        private async Task<int> InsertEvent(SqlConnection connection, SqlTransaction transaction, SqlServerAggregateRepository.DbAggregateEvent @event)
+        {
+            var command = new SqlCommand
+            {
+                Connection = connection,
+                Transaction = transaction,
+                CommandType = CommandType.Text,
+                CommandText = "INSERT INTO AggregateEvents (AggregateId, Version, Type, Data) VALUES(@pAggregateId, @pVersion, @pType, @pData)"
+            };
+
+            command.Parameters.AddWithValue("pAggregateId", @event.AggregateId);
+            command.Parameters.AddWithValue("pVersion", @event.Version);
+            command.Parameters.AddWithValue("pType", @event.Type);
+            command.Parameters.AddWithValue("pData", @event.Data);
+
+            return await command.ExecuteNonQueryAsync();
+        }
+
+        private async Task<SqlServerAggregateRepository.DbAggregate> GetAggregate(string id, SqlConnection connection)
+        {
+            var command = connection.CreateCommand();
+            command.CommandType = CommandType.Text;
+            command.CommandText = @"SELECT Version, Type 
+                                      FROM Aggregates
+                                     WHERE AggregateId = @pAggregateId";
+
+            command.Parameters.AddWithValue("pAggregateId", id);
+
+            using (var reader = await command.ExecuteReaderAsync(CommandBehavior.SingleRow))
+            {
+                if (await reader.ReadAsync())
+                {
+                    int version = reader.GetInt32(reader.GetOrdinal("Version"));
+                    string type = reader.GetString(reader.GetOrdinal("Type"));
+
+                    return new SqlServerAggregateRepository.DbAggregate(id, version, type);
+                }
+
+                return null;
+            }
+        }
+
+        private async Task<String[]> GetAggregateEvents(string id, int minVersion, int maxVersion, SqlConnection connection)
+        {
+            var command = connection.CreateCommand();
+            command.CommandType = CommandType.Text;
+            command.CommandText = @"SELECT Data 
+                                      FROM AggregateEvents 
+                                     WHERE AggregateId = @pAggregateId 
+                                       AND Version >= @pMinVersion
+                                       AND Version <= @pMaxVersion
+                                     ORDER BY Version";
+
+
+            command.Parameters.AddWithValue("pAggregateId", id);
+            command.Parameters.AddWithValue("pMinVersion", minVersion);
+            command.Parameters.AddWithValue("pMaxVersion", maxVersion);
+
+            var results = new List<String>();
+
+            using (var reader = await command.ExecuteReaderAsync(CommandBehavior.SequentialAccess))
+            {
+                while (await reader.ReadAsync())
+                {
+                    string data = reader.GetString(reader.GetOrdinal("Data"));
+
+                    results.Add(data);
+                }
+            }
+
+            return results.ToArray();
+        }
+
         protected virtual string ConvertIdentifierToString(TIdentifier id)
         {
             Guard.NotNull(id, "id");
             return _dataSerializer.Serialize(id);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/iSynaptic.Core.UnitTests/LogicalTypeRegistryBuilder.cs b/src/iSynaptic.Core.UnitTests/LogicalTypeRegistryBuilder.cs
index 761370f..47bcabe 100644
--- a/src/iSynaptic.Core.UnitTests/LogicalTypeRegistryBuilder.cs
+++ b/src/iSynaptic.Core.UnitTests/LogicalTypeRegistryBuilder.cs
@@ -42,6 +42,7 @@ public static LogicalTypeRegistry Build()
 
             registry.AddMapping(new LogicalType("tst", "AggregateMemento.ServiceCaseId"), typeof(AggregateMemento<ServiceCaseId>));
             registry.AddMapping(new LogicalType("tst", "AggregateMemento.RoleIdentifier"), typeof(AggregateMemento<RoleIdentifier>));
+            registry.AddMapping(new LogicalType("tst", "AggregateMemento"), typeof(AggregateMemento));
 
             registry.AddMapping(new LogicalType("tst", "CustomerRoleIdentifier"), typeof(CustomerRoleIdentifier));
             registry.AddMapping(new LogicalType("tst", "CustomerServiceRepresentativeRoleIdentifier"), typeof(CustomerServiceRepresentativeRoleIdentifier));
diff --git a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
index 6b9809f..5f2757f 100644
--- a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
@@ -8,6 +8,196 @@
 
 namespace iSynaptic.Modeling.Domain
 {
+    public abstract class NonGenericAggregateRepositoryTests
+    {
+        protected IAggregateRepository Repo { get; set; }
+
+        [Test]
+        public async Task RoundTrip()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+
+            var reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(1);
+            reconsituted.Id.Should().Be(serviceCase.Id);
+            reconsituted.Version.Should().Be(serviceCase.Version);
+            var reconsitutedServiceCase = (ServiceCase)reconsituted;
+            reconsitutedServiceCase.Title.Should().Be(serviceCase.Title);
+            reconsitutedServiceCase.Description.Should().Be(serviceCase.Description);
+            reconsitutedServiceCase.Priority.Should().Be(serviceCase.Priority);
+
+            var thread = serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic, ServiceCase.SampleContent.TopicDescription, ServiceCase.SampleContent.ResponsibleParty);
+            thread.RecordCommunication(CommunicationDirection.Incoming, ServiceCase.SampleContent.CommunicationContent, SystemClock.UtcNow, ServiceCase.SampleContent.CommunicationDuration, ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+
+            reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(3);
+            var events = reconsituted.GetEvents().ToArray();
+
+            var commRecordedEvent = events[2] as ServiceCase.CommunicationRecorded;
+            commRecordedEvent.Should().NotBeNull();
+            commRecordedEvent.Direction.Should().Be(CommunicationDirection.Incoming);
+            commRecordedEvent.Content.Should().Be(ServiceCase.SampleContent.CommunicationContent);
+            commRecordedEvent.Duration.Should().Be(ServiceCase.SampleContent.CommunicationDuration);
+        }
+
+        [Test]
+        public async Task RoundTrip_UsingSnapshot()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+            await Repo.SaveSnapshot(serviceCase);
+
+            var reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(0);
+            reconsituted.Id.Should().Be(serviceCase.Id);
+            reconsituted.Version.Should().Be(serviceCase.Version);
+            var reconsitutedServiceCase = (ServiceCase) reconsituted;
+            reconsitutedServiceCase.Title.Should().Be(serviceCase.Title);
+            reconsitutedServiceCase.Description.Should().Be(serviceCase.Description);
+            reconsitutedServiceCase.Priority.Should().Be(serviceCase.Priority);
+        }
+
+        [Test]
+        public async Task RoundTrip_WithChangeAfterSnapshot()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+            await Repo.SaveSnapshot(serviceCase);
+
+            serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic,
+                                                 ServiceCase.SampleContent.TopicDescription,
+                                                 ServiceCase.SampleContent.ResponsibleParty);
+            await Repo.Save(serviceCase);
+
+            var reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(1);
+            reconsituted.Id.Should().Be(serviceCase.Id);
+            reconsituted.Version.Should().Be(serviceCase.Version);
+            var reconsitutedServiceCase = (ServiceCase) reconsituted;
+            reconsitutedServiceCase.Title.Should().Be(serviceCase.Title);
+            reconsitutedServiceCase.Description.Should().Be(serviceCase.Description);
+            reconsitutedServiceCase.Priority.Should().Be(serviceCase.Priority);
+        }
+
+        [Test]
+        public async Task RoundTrip_WithMultipleSnapshots()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+            var thread = serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic,
+                                                              ServiceCase.SampleContent.TopicDescription,
+                                                              ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+            await Repo.SaveSnapshot(serviceCase);
+
+            thread.RecordCommunication(CommunicationDirection.Incoming, ServiceCase.SampleContent.CommunicationContent, SystemClock.UtcNow, ServiceCase.SampleContent.CommunicationDuration, ServiceCase.SampleContent.ResponsibleParty);
+            await Repo.Save(serviceCase);
+            await Repo.SaveSnapshot(serviceCase);
+
+            var reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(0);
+            reconsituted.Id.Should().Be(serviceCase.Id);
+            reconsituted.Version.Should().Be(serviceCase.Version);
+            var reconsitutedServiceCase = (ServiceCase) reconsituted;
+            reconsitutedServiceCase.Title.Should().Be(serviceCase.Title);
+            reconsitutedServiceCase.Description.Should().Be(serviceCase.Description);
+            reconsitutedServiceCase.Priority.Should().Be(serviceCase.Priority);
+        }
+
+        [Test]
+        public async Task TakingSnapshot_ForSameVersion_IsOkay()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+            serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic,
+                                                 ServiceCase.SampleContent.TopicDescription,
+                                                 ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+            await Repo.SaveSnapshot(serviceCase);
+            await Repo.SaveSnapshot(serviceCase);
+        }
+
+        [Test]
+        public async Task ConcurrecyConflict_WithTrueConflict_ThrowsException()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+            serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic,
+                                                 ServiceCase.SampleContent.TopicDescription,
+                                                 ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+
+            var winner = (ServiceCase)await Repo.Get(typeof(ServiceCase), serviceCase.Id, Int32.MaxValue);
+            var loser = (ServiceCase)await Repo.Get(typeof(ServiceCase), serviceCase.Id, Int32.MaxValue);
+
+            winner.StartCommunicationThread("Win", "Winning", ServiceCase.SampleContent.ResponsibleParty);
+            await Repo.Save(winner);
+
+            loser.StartCommunicationThread("Lose", "Loosing", ServiceCase.SampleContent.ResponsibleParty);
+
+            try
+            {
+                await Repo.Save(loser);
+                Assert.Fail("Exception was not thrown");
+            }
+            catch (AggregateConcurrencyException)
+            {
+            }
+        }
+
+        [Test]
+        public async Task ConcurrencyConflict_WithFalseConflict_ResolvesConflict()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+            serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic,
+                                                 ServiceCase.SampleContent.TopicDescription,
+                                                 ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+
+            var winner = (ServiceCase)await Repo.Get(typeof(ServiceCase), serviceCase.Id, Int32.MaxValue);
+            var secondWinner = (ServiceCase)await Repo.Get(typeof(ServiceCase), serviceCase.Id, Int32.MaxValue);
+
+            winner.StartCommunicationThread("Win", "Winning", ServiceCase.SampleContent.ResponsibleParty);
+            await Repo.Save(winner);
+
+            secondWinner.Threads.First().RecordCommunication(CommunicationDirection.Outgoing, "Also Win", SystemClock.UtcNow, ServiceCase.SampleContent.CommunicationDuration, ServiceCase.SampleContent.ResponsibleParty);
+            await Repo.Save(secondWinner);
+
+            secondWinner.Version.Should().Be(4);
+            var events = secondWinner.GetEvents().ToArray();
+
+            events[2].Should().BeOfType<ServiceCase.CommunicationThreadStarted>();
+            events[3].Should().BeOfType<ServiceCase.CommunicationRecorded>();
+
+            var cre = (ServiceCase.CommunicationRecorded)events[3];
+            cre.Version.Should().Be(4);
+            cre.Direction.Should().Be(CommunicationDirection.Outgoing);
+            cre.Content.Should().Be("Also Win");
+        }
+    }
+
     public abstract class AggregateRepositoryTests
     {
         protected IAggregateRepository<ServiceCase, ServiceCaseId> Repo { get; set; }
diff --git a/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs
index 037fd42..7d173a7 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs
@@ -20,17 +20,27 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-using System;
 using System.Net;
 using EventStore.ClientAPI;
-using NUnit.Framework;
 using iSynaptic.Core.Persistence;
-using iSynaptic.Modeling;
 using iSynaptic.Modeling.Domain;
 using iSynaptic.TestDomain;
+using NUnit.Framework;
 
 namespace iSynaptic.Persistence
 {
+    [TestFixture]
+    [Explicit("Integration tests - requires EventStore to be running locally.")]
+    public class NonGenericEventStoreAggregateRepositoryTests : NonGenericAggregateRepositoryTests
+    {
+        public NonGenericEventStoreAggregateRepositoryTests()
+        {
+            var ltr = LogicalTypeRegistryBuilder.Build();
+
+            Repo = new EventStoreAggregateRepository(ltr, () => EventStoreConnection.Create(new IPEndPoint(IPAddress.Parse("10.8.80.11"), 1113)));
+        }
+    }
+
     [TestFixture]
     [Explicit("Integration tests - requires EventStore to be running locally.")]
     public class EventStoreAggregateRepositoryTests : AggregateRepositoryTests
@@ -39,7 +49,7 @@ public EventStoreAggregateRepositoryTests()
         {
             var ltr = LogicalTypeRegistryBuilder.Build();
 
-            Repo = new EventStoreAggregateRepository<ServiceCase, ServiceCaseId>(ltr, () => EventStoreConnection.Create(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113)));
+            Repo = new EventStoreAggregateRepository<ServiceCase, ServiceCaseId>(ltr, () => EventStoreConnection.Create(new IPEndPoint(IPAddress.Parse("10.8.80.11"), 1113)));
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/iSynaptic.Core.UnitTests/Persistence/InMemoryAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/InMemoryAggregateRepositoryTests.cs
index ef949e9..8f5b6c2 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/InMemoryAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/InMemoryAggregateRepositoryTests.cs
@@ -20,15 +20,22 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-using System;
-using NUnit.Framework;
 using iSynaptic.Core.Persistence;
-using iSynaptic.Modeling;
 using iSynaptic.Modeling.Domain;
 using iSynaptic.TestDomain;
+using NUnit.Framework;
 
 namespace iSynaptic.Persistence
 {
+    [TestFixture]
+    public class NonGenericInMemoryAggregateRepositoryTests : NonGenericAggregateRepositoryTests
+    {
+        public NonGenericInMemoryAggregateRepositoryTests()
+        {
+            Repo = new InMemoryAggregateRepository();
+        }
+    }
+
     [TestFixture]
     public class InMemoryAggregateRepositoryTests : AggregateRepositoryTests
     {
@@ -37,4 +44,4 @@ public InMemoryAggregateRepositoryTests()
             Repo = new InMemoryAggregateRepository<ServiceCase, ServiceCaseId>();
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/iSynaptic.Core.UnitTests/Persistence/InMemoryJsonAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/InMemoryJsonAggregateRepositoryTests.cs
index e6ff18c..bb407ed 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/InMemoryJsonAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/InMemoryJsonAggregateRepositoryTests.cs
@@ -1,13 +1,42 @@
-using System;
-using NUnit.Framework;
+// The MIT License
+// 
+// Copyright (c) 2013 Jordan E. Terrell
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
 using iSynaptic.Core.Persistence;
-using iSynaptic.Modeling;
 using iSynaptic.Modeling.Domain;
 using iSynaptic.Serialization;
 using iSynaptic.TestDomain;
+using NUnit.Framework;
 
 namespace iSynaptic.Persistence
 {
+    [TestFixture]
+    public class NonGenericInMemoryJsonAggregateRepositoryTests : NonGenericAggregateRepositoryTests
+    {
+        public NonGenericInMemoryJsonAggregateRepositoryTests()
+        {
+            Repo = new InMemoryJsonAggregateRepository(JsonSerializerBuilder.Build(LogicalTypeRegistryBuilder.Build()));
+        }
+    }
+
     [TestFixture]
     public class InMemoryJsonAggregateRepositoryTests : AggregateRepositoryTests
     {
diff --git a/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs
index 3571364..a395965 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs
@@ -20,20 +20,38 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-using System;
-using System.Threading.Tasks;
-using NUnit.Framework;
 using iSynaptic.Core.Persistence;
 using iSynaptic.Modeling.Domain;
 using iSynaptic.TestDomain;
+using NUnit.Framework;
 
 namespace iSynaptic.Persistence
 {
+    [TestFixture]
+    [Explicit("Integration tests - requires Sql Server to be running locally.")]
+    public class NonGenericSqlServerAggregateRepositoryTests : NonGenericAggregateRepositoryTests
+    {
+        private const string ConnectionString = "Data Source=.\\sqlexpress;Initial Catalog=AggregateStore;Integrated Security=true;";
+
+        public NonGenericSqlServerAggregateRepositoryTests()
+        {
+            var ltr = LogicalTypeRegistryBuilder.Build();
+
+            Repo = new SqlServerAggregateRepository(ltr, ConnectionString);
+        }
+
+        [TestFixtureSetUp]
+        public void FixtureSetup()
+        {
+            SqlServerAggregateRepository.EnsureTablesExist(ConnectionString).Wait();
+        }
+    }
+
     [TestFixture]
     [Explicit("Integration tests - requires Sql Server to be running locally.")]
     public class SqlServerAggregateRepositoryTests : AggregateRepositoryTests
     {
-        private const string ConnectionString = "Data Source=(local);Initial Catalog=AggregateStore;Integrated Security=true;";
+        private const string ConnectionString = "Data Source=.\\sqlexpress;Initial Catalog=AggregateStore;Integrated Security=true;";
 
         public SqlServerAggregateRepositoryTests()
         {
@@ -48,4 +66,4 @@ public void FixtureSetup()
             SqlServerAggregateRepository.EnsureTablesExist(ConnectionString).Wait();
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/Aggregate.cs b/src/iSynaptic.Core/Modeling/Domain/Aggregate.cs
index 73054d5..c1f306f 100644
--- a/src/iSynaptic.Core/Modeling/Domain/Aggregate.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/Aggregate.cs
@@ -29,15 +29,11 @@
 
 namespace iSynaptic.Modeling.Domain
 {
-    internal interface IAggregateInternal<out TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    internal interface IAggregateInternal
     {
         void Initialize(IAggregateMemento memento);
-
         void ApplyEvents(IEnumerable<IAggregateEvent> events);
-
         Boolean ConflictsWith(IEnumerable<IAggregateEvent> committedEvents, IEnumerable<IAggregateEvent> attemptedEvents);
-
         void CommitEvents();
     }
 
@@ -54,7 +50,7 @@ public static void FieldsImmuneToReset(Func<FieldInfo, bool> predicate)
         internal static Func<FieldInfo, bool> FieldResetImmunityPredicate { get { return _fieldResetImmunityPredicate; }}
     }
 
-    public abstract class Aggregate<TIdentifier> : IAggregate<TIdentifier>, IAggregateInternal<TIdentifier>
+    public abstract class Aggregate<TIdentifier> : IAggregate<TIdentifier>, IAggregateInternal, IAggregate
         where TIdentifier : IEquatable<TIdentifier>
     {
         [ImmuneToReset]
@@ -96,7 +92,7 @@ private void Initialize(IAggregateMemento memento)
             }
         }
 
-        void IAggregateInternal<TIdentifier>.Initialize(IAggregateMemento memento)
+        void IAggregateInternal.Initialize(IAggregateMemento memento)
         {
             Initialize(memento.ToMemento<TIdentifier>());
         }
@@ -127,7 +123,7 @@ protected void ApplyEvent(IAggregateEvent<TIdentifier> @event)
             ApplyEventsCore(new[] { @event });
         }
 
-        void IAggregateInternal<TIdentifier>.ApplyEvents(IEnumerable<IAggregateEvent> events)
+        void IAggregateInternal.ApplyEvents(IEnumerable<IAggregateEvent> events)
         {
             ApplyEventsCore(events.Cast<IAggregateEvent<TIdentifier>>());
         }
@@ -174,12 +170,12 @@ public IEnumerable<IAggregateEvent<TIdentifier>> GetUncommittedEvents()
             return _events.UncommittedEvents;
         }
 
-        void IAggregateInternal<TIdentifier>.CommitEvents()
+        void IAggregateInternal.CommitEvents()
         {
             _events.CommitEvents();
         }
 
-        Boolean IAggregateInternal<TIdentifier>.ConflictsWith(IEnumerable<IAggregateEvent> committedEvents,
+        Boolean IAggregateInternal.ConflictsWith(IEnumerable<IAggregateEvent> committedEvents,
                                                               IEnumerable<IAggregateEvent> attemptedEvents)
         {
             return ConflictsWith(committedEvents.Cast<IAggregateEvent<TIdentifier>>(),
@@ -196,8 +192,25 @@ from attemptedEvent in attemptedEvents
         }
 
         protected internal virtual Boolean ConflictsWith(IAggregateEvent<TIdentifier> committedEvent, IAggregateEvent<TIdentifier> attemptedEvent) { return true; }
-        
+
         public TIdentifier Id { get; private set; }
         public Int32 Version { get; private set; }
+
+        object IAggregate.Id { get { return Id; } }
+
+        IEnumerable<IAggregateEvent> IAggregate.GetUncommittedEvents()
+        {
+            return GetUncommittedEvents();
+        }
+
+        IEnumerable<IAggregateEvent> IAggregate.GetEvents()
+        {
+            return GetEvents();
+        }
+
+        IAggregateSnapshot IAggregate.TakeSnapshot()
+        {
+            return TakeSnapshot();
+        }
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateEventsLoadFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateEventsLoadFrame.cs
index b8b5607..b10a836 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateEventsLoadFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateEventsLoadFrame.cs
@@ -26,6 +26,17 @@
 
 namespace iSynaptic.Modeling.Domain
 {
+    public class AggregateEventsLoadFrame : AggregateLoadFrame
+    {
+        public AggregateEventsLoadFrame(Type aggregateType, object id, IEnumerable<IAggregateEvent> events)
+            : base(aggregateType, id)
+        {
+            Events = Guard.NotNull(events, "events");
+        }
+
+        public IEnumerable<IAggregateEvent> Events { get; private set; }
+    }
+
     public class AggregateEventsLoadFrame<TIdentifier> : AggregateLoadFrame<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
     {
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateEventsSaveFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateEventsSaveFrame.cs
index 4425a8b..5e0a9e6 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateEventsSaveFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateEventsSaveFrame.cs
@@ -26,6 +26,21 @@
 
 namespace iSynaptic.Modeling.Domain
 {
+    public class AggregateEventsSaveFrame : AggregateSaveFrame
+    {
+        public AggregateEventsSaveFrame(Type aggregateType, object id, Boolean isNew, Int32 expectedVersion, Int32 newVersion, IEnumerable<IAggregateEvent> events)
+            : base(aggregateType, id, isNew)
+        {
+            ExpectedVersion = expectedVersion;
+            NewVersion = newVersion;
+            Events = Guard.NotNull(events, "events");
+        }
+
+        public Int32 ExpectedVersion { get; private set; }
+        public Int32 NewVersion { get; private set; }
+        public IEnumerable<IAggregateEvent> Events { get; private set; }
+    }
+
     public class AggregateEventsSaveFrame<TIdentifier> : AggregateSaveFrame<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
     {
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateLoadFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateLoadFrame.cs
index eba632b..7e6fb0f 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateLoadFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateLoadFrame.cs
@@ -25,6 +25,18 @@
 
 namespace iSynaptic.Modeling.Domain
 {
+    public abstract class AggregateLoadFrame
+    {
+        protected AggregateLoadFrame(Type aggregateType, object id)
+        {
+            AggregateType = Guard.NotNull(aggregateType, "aggregateType");
+            Id = id;
+        }
+
+        public Type AggregateType { get; private set; }
+        public object Id { get; private set; }
+    }
+
     public abstract class AggregateLoadFrame<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
     {
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateMemento.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateMemento.cs
index eafe4f4..f4ea1d4 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateMemento.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateMemento.cs
@@ -27,6 +27,30 @@
 
 namespace iSynaptic.Modeling.Domain
 {
+    public sealed class AggregateMemento : IAggregateMemento
+    {
+        public AggregateMemento(Type aggregateType, Maybe<IAggregateSnapshot> snapshot, IEnumerable<IAggregateEvent> events)
+        {
+            AggregateType = Guard.NotNull(aggregateType, "aggregateType");
+            Snapshot = snapshot;
+            Events = events ?? Enumerable.Empty<IAggregateEvent>();
+        }
+
+        AggregateMemento<TDesiredIdentifier> IAggregateMemento.ToMemento<TDesiredIdentifier>()
+        {
+            var m = this as AggregateMemento<TDesiredIdentifier>;
+
+            return m ?? new AggregateMemento<TDesiredIdentifier>(AggregateType,
+                Snapshot.Cast<IAggregateSnapshot<TDesiredIdentifier>>(),
+                Events.Cast<IAggregateEvent<TDesiredIdentifier>>()
+            );
+        }
+
+        public Type AggregateType { get; private set; }
+        public Maybe<IAggregateSnapshot> Snapshot { get; private set; }
+        public IEnumerable<IAggregateEvent> Events { get; private set; }
+    }
+    
     public sealed class AggregateMemento<TIdentifier> : IAggregateMemento
         where TIdentifier : IEquatable<TIdentifier>
     {
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
index de08cc9..bdf59b4 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
@@ -1,4 +1,4 @@
-// The MIT License
+// The MT License
 // 
 // Copyright (c) 2013 Jordan E. Terrell
 // 
@@ -30,6 +30,144 @@
 
 namespace iSynaptic.Modeling.Domain
 {
+    public abstract class AggregateRepository : IAggregateRepository
+    {
+        private static readonly Task _completedTask = Task.FromResult(true);
+
+        public async Task<IAggregate> Get(Type aggregateType, object id, int maxVersion = int.MaxValue)
+        {
+            var memento = await GetMemento(id, maxVersion);
+
+            if (memento == null)
+                return null;
+
+            var aggregate = (IAggregate)FormatterServices.GetSafeUninitializedObject(aggregateType);
+            var ag = AsInternal(aggregate);
+            ag.Initialize(memento);
+
+            return aggregate;
+        }
+
+        public async Task Save(IAggregate aggregate)
+        {
+            Guard.NotNull(aggregate, "aggregate");
+
+            var ag = AsInternal(aggregate);
+            var aggregateType = aggregate.GetType();
+            var events = aggregate.GetUncommittedEvents().ToArray();
+
+            if (events.Length <= 0)
+                return;
+
+            var firstEvent = events[0];
+
+            int saveAttempts = 0;
+            while (true)
+            {
+                var data = new AggregateEventsSaveFrame(aggregateType, aggregate.Id, firstEvent.Version == 1, firstEvent.Version - 1, aggregate.Version, events);
+
+                AggregateConcurrencyException originalException;
+                try
+                {
+                    saveAttempts++;
+
+                    await SaveEvents(data);
+                    break;
+                }
+                catch (AggregateConcurrencyException ace)
+                {
+                    if (saveAttempts == 3)
+                        throw;
+
+                    originalException = ace;
+                }
+
+                var committedEvents = await GetEvents(aggregate.Id, events[0].Version, Int32.MaxValue);
+                if (ag.ConflictsWith(committedEvents.Events, events))
+                {
+                    throw new AggregateConcurrencyException(originalException.Message,
+                                                            originalException);
+                }
+
+                var newExpectedVersion = committedEvents.Events.Last().Version;
+
+                var memento = await GetMemento(aggregate.Id, newExpectedVersion);
+                ag.Initialize(memento);
+
+                for (int i = 1; i <= events.Length; i++)
+                    ((IAggregateEventInternal)events[i - 1]).Version = newExpectedVersion + i;
+
+                ag.ApplyEvents(events);
+            }
+
+            ag.CommitEvents();
+            await OnEventStreamSaved(aggregateType, aggregate.Id, events);
+        }
+
+        public async Task SaveSnapshot(IAggregate aggregate)
+        {
+            Guard.NotNull(aggregate, "aggregate");
+
+            var snapshot = aggregate.TakeSnapshot();
+            if (snapshot == null)
+                throw new ArgumentException("Aggregate doesn't support snapshots.", "aggregate");
+
+            var ag = AsInternal(aggregate);
+            var aggregateType = aggregate.GetType();
+
+            var events = aggregate.GetUncommittedEvents().ToArray();
+            bool isNew = events.Length > 0 && events[0].Version == 1;
+
+            var data = new AggregateSnapshotSaveFrame(aggregateType, aggregate.Id, isNew, snapshot);
+            await SaveSnapshot(data);
+
+            await OnSnapshotSaved(aggregateType, snapshot);
+        }
+
+        private IAggregateInternal AsInternal(IAggregate aggregate)
+        {
+            var ag = aggregate as IAggregateInternal;
+            if (ag == null) throw new InvalidOperationException("Aggregate must implement IAggregate.");
+            return ag;
+        }
+
+        protected virtual Task OnEventStreamSaved(Type aggregateType, object id, IEnumerable<IAggregateEvent> events) { return _completedTask; }
+        protected virtual Task OnSnapshotSaved(Type aggregateType, IAggregateSnapshot snapshot) { return _completedTask; }
+
+        public async Task<AggregateMemento> GetMemento(object id, Int32 maxVersion)
+        {
+            var snapshotFrame = await GetSnapshot(id, maxVersion);
+            if (snapshotFrame != null)
+            {
+                var snapshot = snapshotFrame.Snapshot;
+                var events = Enumerable.Empty<IAggregateEvent>();
+
+                if (snapshot.Version < maxVersion)
+                {
+                    var eventsFrame = await GetEvents(id, snapshot.Version + 1, maxVersion);
+                    if (eventsFrame != null)
+                        events = eventsFrame.Events;
+                }
+
+                return new AggregateMemento(snapshotFrame.AggregateType, snapshot.ToMaybe(), events);
+            }
+            else
+            {
+                var eventsFrame = await GetEvents(id, 1, maxVersion);
+
+                return eventsFrame != null
+                    ? new AggregateMemento(eventsFrame.AggregateType, Maybe.NoValue, eventsFrame.Events)
+                    : null;
+            }
+        }
+
+        protected abstract Task<AggregateSnapshotLoadFrame> GetSnapshot(object id, Int32 maxVersion);
+        protected abstract Task<AggregateEventsLoadFrame> GetEvents(object id, Int32 minVersion, Int32 maxVersion);
+
+        protected abstract Task SaveSnapshot(AggregateSnapshotSaveFrame frame);
+        protected abstract Task SaveEvents(AggregateEventsSaveFrame frame);
+    }
+
     public abstract class AggregateRepository<TAggregate, TIdentifier> : IAggregateRepository<TAggregate, TIdentifier> 
         where TAggregate : class, IAggregate<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
@@ -131,9 +269,9 @@ public async Task SaveSnapshot(TAggregate aggregate)
             await OnSnapshotSaved(aggregateType, snapshot);
         }
 
-        private IAggregateInternal<TIdentifier> AsInternal(TAggregate aggregate)
+        private IAggregateInternal AsInternal(TAggregate aggregate)
         {
-            var ag = aggregate as IAggregateInternal<TIdentifier>;
+            var ag = aggregate as IAggregateInternal;
             if(ag == null) throw new InvalidOperationException("Aggregate must inherit from Aggregate<TIdentifier>.");
             return ag;
         }
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateSaveFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateSaveFrame.cs
index 86100d5..9d334fa 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateSaveFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateSaveFrame.cs
@@ -25,6 +25,20 @@
 
 namespace iSynaptic.Modeling.Domain
 {
+    public abstract class AggregateSaveFrame
+    {
+        protected AggregateSaveFrame(Type aggregateType, object id, Boolean isNew)
+        {
+            AggregateType = Guard.NotNull(aggregateType, "aggregateType");
+            Id = id;
+            IsNew = isNew;
+        }
+
+        public Type AggregateType { get; private set; }
+        public object Id { get; private set; }
+        public Boolean IsNew { get; private set; }
+    }
+
     public abstract class AggregateSaveFrame<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
     {
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshot.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshot.cs
index 2870d5b..1d6f97d 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshot.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshot.cs
@@ -25,7 +25,7 @@
 namespace iSynaptic.Modeling.Domain
 {
     [Serializable]
-    public abstract class AggregateSnapshot<TIdentifier> : IAggregateSnapshot<TIdentifier>
+    public abstract class AggregateSnapshot<TIdentifier> : IAggregateSnapshot<TIdentifier>, IAggregateSnapshot
         where TIdentifier : IEquatable<TIdentifier>
     {
         protected AggregateSnapshot(TIdentifier id, Int32 version, DateTime takenAt)
@@ -44,6 +44,7 @@ protected AggregateSnapshot(TIdentifier id, Int32 version, DateTime takenAt)
 
         public Guid SnapshotId { get; private set; }
         public TIdentifier Id { get; private set; }
+        object IAggregateSnapshot.Id { get { return ((IAggregateSnapshot<TIdentifier>) this).Id; }}
         public Int32 Version { get; private set; }
         public DateTime TakenAt { get; private set; }
     }
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotLoadFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotLoadFrame.cs
index d860419..66fc186 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotLoadFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotLoadFrame.cs
@@ -25,6 +25,17 @@
 
 namespace iSynaptic.Modeling.Domain
 {
+    public class AggregateSnapshotLoadFrame : AggregateLoadFrame
+    {
+        public AggregateSnapshotLoadFrame(Type aggregateType, object id, IAggregateSnapshot snapshot)
+            : base(aggregateType, id)
+        {
+            Snapshot = Guard.NotNull(snapshot, "snapshot");
+        }
+
+        public IAggregateSnapshot Snapshot { get; private set; }
+    }
+
     public class AggregateSnapshotLoadFrame<TIdentifier> : AggregateLoadFrame<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
     {
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotSaveFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotSaveFrame.cs
index d130912..d7de688 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotSaveFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotSaveFrame.cs
@@ -25,6 +25,17 @@
 
 namespace iSynaptic.Modeling.Domain
 {
+    public class AggregateSnapshotSaveFrame : AggregateSaveFrame
+    {
+        public AggregateSnapshotSaveFrame(Type aggregateType, object id, Boolean isNew, IAggregateSnapshot snapshot)
+            : base(aggregateType, id, isNew)
+        {
+            Snapshot = Guard.NotNull(snapshot, "snapshot");
+        }
+
+        public IAggregateSnapshot Snapshot { get; private set; }
+    }
+
     public class AggregateSnapshotSaveFrame<TIdentifier> : AggregateSaveFrame<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
     {
diff --git a/src/iSynaptic.Core/Modeling/Domain/IAggregate.cs b/src/iSynaptic.Core/Modeling/Domain/IAggregate.cs
index 9006b6c..d78fda8 100644
--- a/src/iSynaptic.Core/Modeling/Domain/IAggregate.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/IAggregate.cs
@@ -3,6 +3,17 @@
 
 namespace iSynaptic.Modeling.Domain
 {
+    public interface IAggregate
+    {
+        object Id { get; }
+        int Version { get; }
+
+        IEnumerable<IAggregateEvent> GetUncommittedEvents();
+        IEnumerable<IAggregateEvent> GetEvents();
+        
+        IAggregateSnapshot TakeSnapshot();
+    }
+
     public interface IAggregate<out TIdentifier> 
         where TIdentifier : IEquatable<TIdentifier>
     {
diff --git a/src/iSynaptic.Core/Modeling/Domain/IAggregateRepository.cs b/src/iSynaptic.Core/Modeling/Domain/IAggregateRepository.cs
index 65b2e1e..fce4a01 100644
--- a/src/iSynaptic.Core/Modeling/Domain/IAggregateRepository.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/IAggregateRepository.cs
@@ -26,6 +26,13 @@
 
 namespace iSynaptic.Modeling.Domain
 {
+    public interface IAggregateRepository
+    {
+        Task<IAggregate> Get(Type aggregateType, object id, int maxVersion = int.MaxValue);
+        Task Save(IAggregate aggregate);
+        Task SaveSnapshot(IAggregate aggregate);
+    }
+
     public interface IAggregateRepository<TAggregate, in TIdentifier> : IAggregateRepositoryCommands<TAggregate, TIdentifier>, IAggregateRepositoryQueries<TAggregate, TIdentifier>
         where TAggregate : IAggregate<TIdentifier> 
         where TIdentifier : IEquatable<TIdentifier>
diff --git a/src/iSynaptic.Core/Modeling/Domain/IAggregateSnapshot.cs b/src/iSynaptic.Core/Modeling/Domain/IAggregateSnapshot.cs
index 90ff920..a36e23c 100644
--- a/src/iSynaptic.Core/Modeling/Domain/IAggregateSnapshot.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/IAggregateSnapshot.cs
@@ -24,14 +24,19 @@
 
 namespace iSynaptic.Modeling.Domain
 {
-    public interface IAggregateSnapshot<out TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    public interface IAggregateSnapshot
     {
         Guid SnapshotId { get; }
 
-        TIdentifier Id { get; }
+        object Id { get; }
         Int32 Version { get; }
 
         DateTime TakenAt { get; }
     }
+
+    public interface IAggregateSnapshot<out TIdentifier> : IAggregateSnapshot
+        where TIdentifier : IEquatable<TIdentifier>
+    {
+        new TIdentifier Id { get; }
+    }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/IScalarValue.cs b/src/iSynaptic.Core/Modeling/Domain/IScalarValue.cs
index a3a3b07..b53944e 100644
--- a/src/iSynaptic.Core/Modeling/Domain/IScalarValue.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/IScalarValue.cs
@@ -20,6 +20,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+using System;
+
 namespace iSynaptic.Modeling.Domain
 {
     public interface IScalarValue

From aecb629e251df692a793d02f5536b7c3ed320dc0 Mon Sep 17 00:00:00 2001
From: Bill Biwer <bill.biwer@young-america.com>
Date: Mon, 18 May 2015 14:23:02 -0500
Subject: [PATCH 2/6] Added SaveEvents method to non-generic aggregate
 repository

---
 .../Domain/AggregateRepositoryTests.cs        | 43 +++++++++++++++++++
 .../Modeling/Domain/AggregateRepository.cs    | 17 ++++++++
 .../Modeling/Domain/IAggregateRepository.cs   |  2 +
 3 files changed, 62 insertions(+)

diff --git a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
index 5f2757f..e9f270d 100644
--- a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
@@ -4,6 +4,7 @@
 using FluentAssertions;
 using NUnit.Framework;
 using iSynaptic.Commons;
+using iSynaptic.Commons.Linq;
 using iSynaptic.TestDomain;
 
 namespace iSynaptic.Modeling.Domain
@@ -12,6 +13,48 @@ public abstract class NonGenericAggregateRepositoryTests
     {
         protected IAggregateRepository Repo { get; set; }
 
+        [Test]
+        public async Task SaveEvents_NewAggregate()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+            var events = ((IAggregate)serviceCase).GetEvents();
+
+            await Repo.SaveEvents(typeof(ServiceCase), serviceCase.Id, events);
+
+            var reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(1);
+            reconsituted.Id.Should().Be(serviceCase.Id);
+            reconsituted.Version.Should().Be(serviceCase.Version);
+            var reconsitutedServiceCase = (ServiceCase)reconsituted;
+            reconsitutedServiceCase.Title.Should().Be(serviceCase.Title);
+            reconsitutedServiceCase.Description.Should().Be(serviceCase.Description);
+            reconsitutedServiceCase.Priority.Should().Be(serviceCase.Priority);
+        }
+
+        [Test]
+        public async Task SaveEvents_ExistingAggregate()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+            await Repo.Save(serviceCase);
+
+            var thread = serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic, ServiceCase.SampleContent.TopicDescription, ServiceCase.SampleContent.ResponsibleParty);
+            var events = ((IAggregate)serviceCase).GetUncommittedEvents().ToArray();
+            events.Length.Should().Be(1);
+
+            await Repo.SaveEvents(typeof(ServiceCase), serviceCase.Id, events);
+
+            var reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(2);
+            reconsituted.Id.Should().Be(serviceCase.Id);
+            reconsituted.Version.Should().Be(serviceCase.Version);
+        }
+
         [Test]
         public async Task RoundTrip()
         {
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
index bdf59b4..62b67fb 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
@@ -124,6 +124,23 @@ public async Task SaveSnapshot(IAggregate aggregate)
             await OnSnapshotSaved(aggregateType, snapshot);
         }
 
+        public async Task SaveEvents(Type aggregateType, object id, IEnumerable<IAggregateEvent> events)
+        {
+            Guard.NotNull(aggregateType, "aggregateType");
+            Guard.NotNull(id, "id");
+            Guard.NotNull(events, "events");
+
+            var eventsToSave = events as IAggregateEvent[] ?? events.ToArray();
+            if (eventsToSave.Length <= 0)
+                return;
+
+            var firstEvent = eventsToSave[0];
+            var data = new AggregateEventsSaveFrame(aggregateType, id, firstEvent.Version == 1, firstEvent.Version - 1, firstEvent.Version + eventsToSave.Length, eventsToSave);
+
+            await SaveEvents(data);
+            await OnEventStreamSaved(aggregateType, id, eventsToSave);
+        }
+
         private IAggregateInternal AsInternal(IAggregate aggregate)
         {
             var ag = aggregate as IAggregateInternal;
diff --git a/src/iSynaptic.Core/Modeling/Domain/IAggregateRepository.cs b/src/iSynaptic.Core/Modeling/Domain/IAggregateRepository.cs
index fce4a01..7ab562d 100644
--- a/src/iSynaptic.Core/Modeling/Domain/IAggregateRepository.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/IAggregateRepository.cs
@@ -21,6 +21,7 @@
 // THE SOFTWARE.
 
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using iSynaptic.Commons.Threading.Tasks;
 
@@ -31,6 +32,7 @@ public interface IAggregateRepository
         Task<IAggregate> Get(Type aggregateType, object id, int maxVersion = int.MaxValue);
         Task Save(IAggregate aggregate);
         Task SaveSnapshot(IAggregate aggregate);
+        Task SaveEvents(Type aggregateType, object id, IEnumerable<IAggregateEvent> events);
     }
 
     public interface IAggregateRepository<TAggregate, in TIdentifier> : IAggregateRepositoryCommands<TAggregate, TIdentifier>, IAggregateRepositoryQueries<TAggregate, TIdentifier>

From 05d55ace5fd4b417192e9de813840352e8df976e Mon Sep 17 00:00:00 2001
From: Bill Biwer <bill.biwer@young-america.com>
Date: Mon, 18 May 2015 14:30:29 -0500
Subject: [PATCH 3/6] Cleanup to ES aggregate repo

---
 .../EventStoreAggregateRepository.cs                         | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs b/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs
index 571ea82..f4a0391 100644
--- a/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs
@@ -40,10 +40,7 @@ public class EventStoreAggregateRepository : AggregateRepository
         private static readonly EventData _offsetEvent = new EventData(_offsetEventId, "streamOffset", true, Encoding.Default.GetBytes("{}"), null);
 
         private readonly ILogicalTypeRegistry _logicalTypeRegistry;
-
         private readonly JsonSerializer _dataSerializer;
-        private readonly JsonSerializer _metadataSerializer;
-
         private readonly Func<IEventStoreConnection> _connectionFactory;
 
         public EventStoreAggregateRepository(ILogicalTypeRegistry logicalTypeRegistry, Func<IEventStoreConnection> connectionFactory)
@@ -55,8 +52,6 @@ public EventStoreAggregateRepository(ILogicalTypeRegistry logicalTypeRegistry, F
 
             var metadataSerializerSettings = JsonSerializerBuilder.BuildSettings(logicalTypeRegistry);
             metadataSerializerSettings.TypeNameHandling = TypeNameHandling.None;
-
-            _metadataSerializer = JsonSerializer.Create(metadataSerializerSettings);
         }
 
         protected override async Task<AggregateEventsLoadFrame> GetEvents(object id, int minVersion, int maxVersion)

From 32107470c0a81c5afd1f5c5d0d7c1247869b2d0a Mon Sep 17 00:00:00 2001
From: Bill Biwer <bill.biwer@young-america.com>
Date: Mon, 18 May 2015 15:03:54 -0500
Subject: [PATCH 4/6] Added check to AggregateRepository to ensure the
 specified aggregateType implements IAggregate

---
 .../Modeling/Domain/AggregateRepositoryTests.cs            | 7 ++++++-
 src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs  | 4 ++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
index e9f270d..60359a1 100644
--- a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
@@ -4,7 +4,6 @@
 using FluentAssertions;
 using NUnit.Framework;
 using iSynaptic.Commons;
-using iSynaptic.Commons.Linq;
 using iSynaptic.TestDomain;
 
 namespace iSynaptic.Modeling.Domain
@@ -13,6 +12,12 @@ public abstract class NonGenericAggregateRepositoryTests
     {
         protected IAggregateRepository Repo { get; set; }
 
+        [Test, ExpectedExceptionAttribute(typeof (ArgumentException))]
+        public async Task Get_InvalidAggregateType_Throws()
+        {
+            await Repo.Get(typeof (string), 1);
+        }
+
         [Test]
         public async Task SaveEvents_NewAggregate()
         {
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
index 62b67fb..0067bf7 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
@@ -26,6 +26,7 @@
 using System.Runtime.Serialization;
 using System.Threading.Tasks;
 using iSynaptic.Commons;
+using iSynaptic.Commons.Reflection;
 using iSynaptic.Commons.Threading.Tasks;
 
 namespace iSynaptic.Modeling.Domain
@@ -36,6 +37,9 @@ public abstract class AggregateRepository : IAggregateRepository
 
         public async Task<IAggregate> Get(Type aggregateType, object id, int maxVersion = int.MaxValue)
         {
+            if (!aggregateType.DoesImplementType(typeof(IAggregate)))
+                throw new ArgumentException("AggregateType must implement IAggregate.");
+
             var memento = await GetMemento(id, maxVersion);
 
             if (memento == null)

From 020053b6b31dbcee6ccd9fd45858ab3a140aff54 Mon Sep 17 00:00:00 2001
From: Bill Biwer <bill.biwer@young-america.com>
Date: Wed, 20 May 2015 14:35:55 -0500
Subject: [PATCH 5/6] Replaced AggregateRepository<TAg,TId> with
 AggregateRepository as primary class; dropped generic event frame and
 snapshot classes

---
 .../AggregateSnapshotCodeAuthoringVisitor.cs  |   4 +-
 .../EventStoreAggregateRepository.cs          | 231 +--------------
 .../InMemoryAggregateRepository.cs            |  34 +--
 .../InMemoryJsonAggregateRepository.cs        |  35 +--
 .../MementoBasedAggregateRepository.cs        |  75 +----
 .../SqlServerAggregateRepository.cs           | 262 +-----------------
 .../LogicalTypeRegistryBuilder.cs             |   2 -
 .../Modeling/Domain/AggregateMementoTests.cs  |   4 +-
 .../Domain/AggregateRepositoryTests.cs        |   4 +-
 .../EventStoreAggregateRepositoryTests.cs     |   8 +-
 .../InMemoryAggregateRepositoryTests.cs       |   8 +-
 .../InMemoryJsonAggregateRepositoryTests.cs   |   8 +-
 .../SqlServerAggregateRepositoryTests.cs      |   8 +-
 .../TestDomain/Generated.cs                   |   2 +-
 .../TestDomain/ServiceCase.cs                 |   2 +-
 .../Modeling/Domain/Aggregate.cs              |  22 +-
 .../Domain/AggregateEventsLoadFrame.cs        |  12 -
 .../Domain/AggregateEventsSaveFrame.cs        |  16 --
 .../Modeling/Domain/AggregateHelper.cs        |   4 +-
 .../Modeling/Domain/AggregateMemento.cs       |  37 +--
 .../Modeling/Domain/AggregateRepository.cs    | 154 ++--------
 .../Modeling/Domain/AggregateSnapshot.cs      |   8 +-
 .../Domain/AggregateSnapshotLoadFrame.cs      |  12 -
 .../Domain/AggregateSnapshotSaveFrame.cs      |  12 -
 .../Modeling/Domain/IAggregate.cs             |   9 +-
 .../Modeling/Domain/IAggregateMemento.cs      |  32 ---
 .../Modeling/Domain/IAggregateSnapshot.cs     |   6 -
 src/iSynaptic.Core/iSynaptic.Core.csproj      |   1 -
 28 files changed, 93 insertions(+), 919 deletions(-)
 delete mode 100644 src/iSynaptic.Core/Modeling/Domain/IAggregateMemento.cs

diff --git a/src/iSynaptic.Core.CodeGeneration/Modeling/Domain/AggregateSnapshotCodeAuthoringVisitor.cs b/src/iSynaptic.Core.CodeGeneration/Modeling/Domain/AggregateSnapshotCodeAuthoringVisitor.cs
index cf7d696..d0b27aa 100644
--- a/src/iSynaptic.Core.CodeGeneration/Modeling/Domain/AggregateSnapshotCodeAuthoringVisitor.cs
+++ b/src/iSynaptic.Core.CodeGeneration/Modeling/Domain/AggregateSnapshotCodeAuthoringVisitor.cs
@@ -60,10 +60,8 @@ protected override Maybe<string> GetBaseMolecule(MoleculeSyntax molecule)
         {
             var aggregate = (AggregateSyntax)molecule.Parent;
 
-            var id = aggregate.GetIdTypeName(SymbolTable);
-
             return base.GetBaseMolecule(molecule)
-                       .Or(String.Format("AggregateSnapshot<{0}>", id));
+                       .Or("AggregateSnapshot");
         }
 
         protected override bool ShouldBeEquatable(MoleculeSyntax molecule)
diff --git a/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs b/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs
index f4a0391..6660f50 100644
--- a/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs
@@ -268,236 +268,9 @@ public class EventStoreAggregateRepository<TAggregate, TIdentifier> : AggregateR
         where TAggregate : class, IAggregate<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
     {
-        private static readonly Guid _offsetEventId = new Guid(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
-        private static readonly EventData _offsetEvent = new EventData(_offsetEventId, "streamOffset", true, Encoding.Default.GetBytes("{}"), null);
-
-        private readonly ILogicalTypeRegistry _logicalTypeRegistry;
-
-        private readonly JsonSerializer _dataSerializer;
-        private readonly JsonSerializer _metadataSerializer;
-
-        private readonly Func<IEventStoreConnection> _connectionFactory;
-
         public EventStoreAggregateRepository(ILogicalTypeRegistry logicalTypeRegistry, Func<IEventStoreConnection> connectionFactory)
+            :base(new EventStoreAggregateRepository(logicalTypeRegistry, connectionFactory))
         {
-            _logicalTypeRegistry = Guard.NotNull(logicalTypeRegistry, "logicalTypeRegistry");
-            _connectionFactory = Guard.NotNull(connectionFactory, "connectionFactory");
-
-            _dataSerializer = JsonSerializerBuilder.Build(logicalTypeRegistry);
-
-            var metadataSerializerSettings = JsonSerializerBuilder.BuildSettings(logicalTypeRegistry);
-            metadataSerializerSettings.TypeNameHandling = TypeNameHandling.None;
-
-            _metadataSerializer = JsonSerializer.Create(metadataSerializerSettings);
-        }
-
-        protected override async Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(TIdentifier id, int minVersion, int maxVersion)
-        {
-            var maxCount = (maxVersion - minVersion) + 1;
-
-            if (maxCount <= 0)
-                return null;
-
-            using (var cn = _connectionFactory())
-            {
-                await cn.ConnectAsync().ConfigureAwait(false);
-
-                String streamId = BuildStreamIdentifier(id);
-
-                var metadataResult = await cn.GetStreamMetadataAsync(streamId).ConfigureAwait(false);
-                if (metadataResult.MetastreamVersion == ExpectedVersion.NoStream)
-                    return null;
-
-                string aggregateTypeString;
-
-                if (!metadataResult.StreamMetadata.TryGetValue("aggregateType", out aggregateTypeString))
-                {
-                    throw new InvalidOperationException("Aggregate type is not specified in event stream metadata.");
-                }
-
-                var resolvedEvents = (await cn.ReadStreamEventsForwardAsync(streamId, minVersion, maxCount, false).ConfigureAwait(false))
-                    .ToMaybe()
-                    .Where(x => x.Status == SliceReadStatus.Success)
-                    .SelectMany(x => x.Events)
-                    .ToArray();
-
-                if (resolvedEvents.Length > 0)
-                {
-                    Type aggregateType = _logicalTypeRegistry.LookupActualType(LogicalType.Parse(aggregateTypeString));
-
-                    var events = resolvedEvents
-                        .Select(x => x.Event.Data)
-                        .Select(Encoding.Default.GetString)
-                        .Select(x => _dataSerializer.Deserialize<IAggregateEvent<TIdentifier>>(x));
-
-                    return new AggregateEventsLoadFrame<TIdentifier>(aggregateType, id, events);
-                }
-
-                return null;
-            }
-        }
-
-        protected async override Task SaveEvents(AggregateEventsSaveFrame<TIdentifier> frame)
-        {
-            var aggregateType = frame.AggregateType;
-            var id = frame.Id;
-            var evts = frame.Events.ToArray();
-
-            if (evts.Length <= 0)
-                throw new ArgumentException("There are no events to save.", "frame");
-
-            String streamId = BuildStreamIdentifier(id);
-            using (var cn = _connectionFactory())
-            {
-                await cn.ConnectAsync().ConfigureAwait(false);
-
-                bool isNewStream = evts[0].Version == 1;
-
-                try
-                {
-                    var events = evts.Select(e => BuildEventData(e.EventId, e, aggregateType));
-
-                    if (isNewStream)
-                    {
-                        var metadata = BuildStreamMetadata(aggregateType);
-                        await cn.SetStreamMetadataAsync(streamId, ExpectedVersion.NoStream, metadata).ConfigureAwait(false);
-
-                        events = new[] { _offsetEvent }.Concat(events);
-                    }
-
-                    int expectedVersion = isNewStream
-                        ? ExpectedVersion.EmptyStream
-                        : evts[0].Version - 1;
-
-                    await cn.AppendToStreamAsync(
-                        streamId,
-                        expectedVersion,
-                        events).ConfigureAwait(false);
-
-                }
-                catch (WrongExpectedVersionException ex)
-                {
-                    throw new AggregateConcurrencyException(ex);
-                }
-            }
-        }
-
-        protected override async Task<AggregateSnapshotLoadFrame<TIdentifier>> GetSnapshot(TIdentifier id, int maxVersion)
-        {
-            using (var cn = _connectionFactory())
-            {
-                await cn.ConnectAsync().ConfigureAwait(false);
-
-                String snapshotStreamId = BuildSnapshotStreamIdentifier(id);
-
-                var metadataResult = await cn.GetStreamMetadataAsync(snapshotStreamId).ConfigureAwait(false);
-                if (metadataResult.MetastreamVersion == ExpectedVersion.NoStream)
-                    return null;
-
-                string aggregateTypeString;
-
-                if (!metadataResult.StreamMetadata.TryGetValue("aggregateType", out aggregateTypeString))
-                {
-                    throw new InvalidOperationException("Aggregate type is not specified in event stream metadata.");
-                }
-                
-                var resolvedEvent = (await cn.ReadStreamEventsForwardAsync(snapshotStreamId, 0, int.MaxValue, false).ConfigureAwait(false))
-                    .ToMaybe()
-                    .Where(x => x.Status == SliceReadStatus.Success)
-                    .SelectMany(x => x.Events)
-                    .TrySingle();
-
-                var snapshot = resolvedEvent
-                    .Select(x => x.Event.Data)
-                    .Select(Encoding.Default.GetString)
-                    .Select(x => _dataSerializer.Deserialize<IAggregateSnapshot<TIdentifier>>(x))
-                    .Where(x => x.Version <= maxVersion);
-
-                if (snapshot.HasValue)
-                {
-                    Type aggregateType = _logicalTypeRegistry.LookupActualType(LogicalType.Parse(aggregateTypeString));
-
-                    return new AggregateSnapshotLoadFrame<TIdentifier>(aggregateType, id, snapshot.Value);
-                }
-
-                return null;
-            }
-        }
-
-        protected async override Task SaveSnapshot(AggregateSnapshotSaveFrame<TIdentifier> frame)
-        {
-            using (var cn = _connectionFactory())
-            {
-                await cn.ConnectAsync().ConfigureAwait(false);
-
-                var aggregateType = frame.AggregateType;
-                var id = frame.Id;
-                var snapshot = frame.Snapshot;
-
-                String streamId = BuildSnapshotStreamIdentifier(id);
-
-                var metadata = BuildSnapshotStreamMetadata(aggregateType);
-
-                var stream = await cn.ReadStreamEventsForwardAsync(streamId, 0, int.MaxValue, false).ConfigureAwait(false);
-                if (stream.Status == SliceReadStatus.StreamNotFound)
-                {
-                    await cn.SetStreamMetadataAsync(streamId, ExpectedVersion.NoStream, metadata).ConfigureAwait(false);
-
-                    await cn.AppendToStreamAsync(
-                        streamId,
-                        ExpectedVersion.EmptyStream,
-                        BuildEventData(
-                            snapshot.SnapshotId,
-                            snapshot,
-                            aggregateType)
-                        ).ConfigureAwait(false);
-                }
-                else
-                {
-                    await cn.AppendToStreamAsync(
-                        streamId,
-                        stream.LastEventNumber,
-                        BuildEventData(
-                            snapshot.SnapshotId,
-                            snapshot,
-                            aggregateType)
-                    ).ConfigureAwait(false);    
-                }
-            }
-        }
-
-        private StreamMetadata BuildSnapshotStreamMetadata(Type aggregateType)
-        {
-            return StreamMetadata.Build()
-                .SetMaxCount(1)
-                .SetCustomProperty("aggregateType", _logicalTypeRegistry.LookupLogicalType(aggregateType).ToString())
-                .Build();
-        }
-
-        private StreamMetadata BuildStreamMetadata(Type aggregateType)
-        {
-            return StreamMetadata.Build()
-                .SetCustomProperty("aggregateType", _logicalTypeRegistry.LookupLogicalType(aggregateType).ToString())
-                .Build();
-        }
-
-        protected EventData BuildEventData(Guid id, object data, Type aggregateType)
-        {
-            return new EventData(id,
-                _logicalTypeRegistry.LookupLogicalType(data.GetType()).ToString(),
-                true,
-                Encoding.Default.GetBytes(_dataSerializer.Serialize(data)),
-                null);
-        }
-
-        protected virtual String BuildStreamIdentifier(TIdentifier id)
-        {
-            return _dataSerializer.Serialize(id);
-        }
-
-        protected virtual String BuildSnapshotStreamIdentifier(TIdentifier id)
-        {
-            return String.Format("{0}-snapshot", BuildStreamIdentifier(id));
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/iSynaptic.Core.Persistence/InMemoryAggregateRepository.cs b/src/iSynaptic.Core.Persistence/InMemoryAggregateRepository.cs
index e6e89ed..431dd9c 100644
--- a/src/iSynaptic.Core.Persistence/InMemoryAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/InMemoryAggregateRepository.cs
@@ -32,8 +32,7 @@ namespace iSynaptic.Core.Persistence
 {
     public class InMemoryAggregateRepository : MementoBasedAggregateRepository
     {
-        private readonly Dictionary<object, AggregateMemento> _state =
-            new Dictionary<object, AggregateMemento>();
+        private readonly Dictionary<object, AggregateMemento> _state = new Dictionary<object, AggregateMemento>();
 
         protected override Task<Maybe<AggregateMemento>> TryLoadMemento(object id)
         {
@@ -63,38 +62,13 @@ protected override async Task StoreMemento(Func<Task<KeyValuePair<object, Aggreg
         }
     }
 
-    public class InMemoryAggregateRepository<TAggregate, TIdentifier> : MementoBasedAggregateRepository<TAggregate, TIdentifier>
+    public class InMemoryAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
         where TAggregate : class, IAggregate<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
     {
-        private readonly Dictionary<TIdentifier, AggregateMemento<TIdentifier>> _state =
-            new Dictionary<TIdentifier, AggregateMemento<TIdentifier>>();
-
-        protected override Task<Maybe<AggregateMemento<TIdentifier>>> TryLoadMemento(TIdentifier id)
-        {
-            lock (_state)
-            {
-                return Task.FromResult(_state.TryGetValue(id));
-            }
-        }
-
-        protected override async Task StoreMemento(Func<Task<KeyValuePair<TIdentifier, AggregateMemento<TIdentifier>>>> mementoFactory)
+        public InMemoryAggregateRepository()
+            : base(new InMemoryAggregateRepository())
         {
-            bool lockTaken = false;
-            
-            try
-            {
-                Monitor.Enter(_state, ref lockTaken);
-
-                var memento = await mementoFactory();
-                _state[memento.Key] = memento.Value;
-                
-            }
-            finally
-            {
-                if(lockTaken)
-                    Monitor.Exit(_state);
-            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core.Persistence/InMemoryJsonAggregateRepository.cs b/src/iSynaptic.Core.Persistence/InMemoryJsonAggregateRepository.cs
index d312f14..6c427ed 100644
--- a/src/iSynaptic.Core.Persistence/InMemoryJsonAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/InMemoryJsonAggregateRepository.cs
@@ -34,8 +34,7 @@ namespace iSynaptic.Core.Persistence
 {
     public class InMemoryJsonAggregateRepository : MementoBasedAggregateRepository
     {
-        private readonly Dictionary<String, String> _state =
-            new Dictionary<String, String>();
+        private readonly Dictionary<String, String> _state = new Dictionary<String, String>();
 
         private readonly JsonSerializer _serializer;
 
@@ -68,41 +67,13 @@ protected override async Task StoreMemento(Func<Task<KeyValuePair<object, Aggreg
         }
     }
 
-    public class InMemoryJsonAggregateRepository<TAggregate, TIdentifier> : MementoBasedAggregateRepository<TAggregate, TIdentifier>
+    public class InMemoryJsonAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
         where TAggregate : class, IAggregate<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
     {
-        private readonly Dictionary<String, String> _state =
-            new Dictionary<String, String>();
-
-        private readonly JsonSerializer _serializer;
-
         public InMemoryJsonAggregateRepository(JsonSerializer serializer)
+            : base(new InMemoryJsonAggregateRepository(serializer))
         {
-            _serializer = Guard.NotNull(serializer, "serializer");
-        }
-
-        protected override Task<Maybe<AggregateMemento<TIdentifier>>> TryLoadMemento(TIdentifier id)
-        {
-            return Task.FromResult(_state.TryGetValue(_serializer.Serialize(id))
-                       .Select(json => _serializer.Deserialize<AggregateMemento<TIdentifier>>(json)));
-        }
-
-        protected override async Task StoreMemento(Func<Task<KeyValuePair<TIdentifier, AggregateMemento<TIdentifier>>>> mementoFactory)
-        {
-            bool lockTaken = false;
-            try
-            {
-                Monitor.Enter(_state, ref lockTaken);
-                
-                var memento = await mementoFactory();
-                _state[_serializer.Serialize(memento.Key)] = _serializer.Serialize(memento.Value);
-            }
-            finally
-            {
-                if(lockTaken)
-                    Monitor.Exit(_state);
-            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core.Persistence/MementoBasedAggregateRepository.cs b/src/iSynaptic.Core.Persistence/MementoBasedAggregateRepository.cs
index dffee48..b6f13b5 100644
--- a/src/iSynaptic.Core.Persistence/MementoBasedAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/MementoBasedAggregateRepository.cs
@@ -48,11 +48,11 @@ protected override async Task<AggregateEventsLoadFrame> GetEvents(object id, int
         {
             return (await TryLoadMemento(id))
                 .Select(x => new AggregateEventsLoadFrame(
-                                 x.AggregateType,
-                                 id,
-                                 x.Events
-                                  .SkipWhile(y => y.Version < minVersion)
-                                  .TakeWhile(y => y.Version <= maxVersion)))
+                    x.AggregateType,
+                    id,
+                    x.Events
+                        .SkipWhile(y => y.Version < minVersion)
+                        .TakeWhile(y => y.Version <= maxVersion)))
                 .ValueOrDefault();
         }
 
@@ -93,69 +93,4 @@ protected override Task SaveEvents(AggregateEventsSaveFrame frame)
                     .ValueOrDefault(() => new AggregateMemento(aggregateType, Maybe<IAggregateSnapshot>.NoValue, events))));
         }
     }
-
-    public abstract class MementoBasedAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
-        where TAggregate : class, IAggregate<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
-    {
-        protected abstract Task<Maybe<AggregateMemento<TIdentifier>>> TryLoadMemento(TIdentifier id);
-        protected abstract Task StoreMemento(Func<Task<KeyValuePair<TIdentifier, AggregateMemento<TIdentifier>>>> mementoFactory);
-
-        protected override async Task<AggregateSnapshotLoadFrame<TIdentifier>> GetSnapshot(TIdentifier id, int maxVersion)
-        {
-            return (await TryLoadMemento(id))
-                .Where(x => x.Snapshot.Select(y => y.Version <= maxVersion).ValueOrDefault())
-                .Select(x => new AggregateSnapshotLoadFrame<TIdentifier>(x.AggregateType, id, x.Snapshot.Value))
-                .ValueOrDefault();
-        }
-
-        protected override async Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(TIdentifier id, int minVersion, int maxVersion)
-        {
-            return (await TryLoadMemento(id))
-                .Select(x => new AggregateEventsLoadFrame<TIdentifier>(
-                                 x.AggregateType,
-                                 id,
-                                 x.Events
-                                  .SkipWhile(y => y.Version < minVersion)
-                                  .TakeWhile(y => y.Version <= maxVersion)))
-                .ValueOrDefault();
-        }
-
-        protected override Task SaveSnapshot(AggregateSnapshotSaveFrame<TIdentifier> frame)
-        {
-            return StoreMemento(async () =>
-            {
-                var aggregateType = frame.AggregateType;
-                var snapshot = frame.Snapshot;
-
-                var state = (await TryLoadMemento(snapshot.Id)).ValueOrDefault();
-
-                return KeyValuePair.Create(snapshot.Id, new AggregateMemento<TIdentifier>(aggregateType, snapshot.ToMaybe(), state != null ? state.Events : null));
-            });
-        }
-
-        protected override Task SaveEvents(AggregateEventsSaveFrame<TIdentifier> frame)
-        {
-            var aggregateType = frame.AggregateType;
-            var id = frame.Id;
-            var events = frame.Events.ToArray();
-
-            return StoreMemento(async () => 
-                KeyValuePair.Create(id, (await TryLoadMemento(id))
-                    .Select(x =>
-                    {
-                        var lastEvent = x.Events.TryLast();
-                        var actualVersion = lastEvent.Select(y => y.Version).ValueOrDefault();
-
-                        if(actualVersion != frame.ExpectedVersion)
-                            throw new AggregateConcurrencyException();
-
-                        return new AggregateMemento<TIdentifier>(
-                            aggregateType,
-                            x.Snapshot,
-                            x.Events.Concat(events.SkipWhile(y => y.Version <= lastEvent.Select(z => z.Version).ValueOrDefault())));
-                    })
-                    .ValueOrDefault(() => new AggregateMemento<TIdentifier>(aggregateType, Maybe<IAggregateSnapshot<TIdentifier>>.NoValue, events))));
-        }
-    }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core.Persistence/SqlServerAggregateRepository.cs b/src/iSynaptic.Core.Persistence/SqlServerAggregateRepository.cs
index 8d1380f..f25d1d3 100644
--- a/src/iSynaptic.Core.Persistence/SqlServerAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/SqlServerAggregateRepository.cs
@@ -71,7 +71,7 @@ public static async Task EnsureTablesExist(string connectionString)
 
         #region Helper Classes
 
-        internal abstract class DbRow
+        private abstract class DbRow
         {
             private string _aggregateId;
             private int _version;
@@ -126,7 +126,7 @@ public string Type
             }
         }
 
-        internal abstract class DbDataRow : DbRow
+        private abstract class DbDataRow : DbRow
         {
             private string _data;
 
@@ -151,7 +151,7 @@ public string Data
             }
         }
 
-        internal class DbAggregate : DbRow
+        private class DbAggregate : DbRow
         {
             public DbAggregate(string aggregateId, int version, string type)
                 : base(aggregateId, version, type)
@@ -159,7 +159,7 @@ public DbAggregate(string aggregateId, int version, string type)
             }
         }
 
-        internal class DbAggregateEvent : DbDataRow
+        private class DbAggregateEvent : DbDataRow
         {
             public DbAggregateEvent(string aggregateId, int version, string type, string data)
                 : base(aggregateId, version, type, data)
@@ -167,7 +167,7 @@ public DbAggregateEvent(string aggregateId, int version, string type, string dat
             }
         }
 
-        internal class DbAggregateSnapshot : DbDataRow
+        private class DbAggregateSnapshot : DbDataRow
         {
             public DbAggregateSnapshot(string aggregateId, int version, string type, string data)
                 : base(aggregateId, version, type, data)
@@ -331,7 +331,7 @@ protected override async Task SaveEvents(AggregateEventsSaveFrame frame)
             }
         }
 
-        internal static async Task UpsertAggregate(SqlConnection connection, SqlTransaction transaction, string idString, int expectedVersion, int newVersion, string type)
+        private static async Task UpsertAggregate(SqlConnection connection, SqlTransaction transaction, string idString, int expectedVersion, int newVersion, string type)
         {
             bool isNewAggregate = expectedVersion == 0;
             if (isNewAggregate)
@@ -359,7 +359,7 @@ internal static async Task UpsertAggregate(SqlConnection connection, SqlTransact
             }
         }
 
-        internal static async Task InsertAggregate(SqlConnection connection, SqlTransaction transaction, string idString, int newVersion, string type)
+        private static async Task InsertAggregate(SqlConnection connection, SqlTransaction transaction, string idString, int newVersion, string type)
         {
             var insertCommand = new SqlCommand
             {
@@ -476,256 +476,12 @@ protected virtual string ConvertIdentifierToString(object id)
     }
 
     public class SqlServerAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
-        where TAggregate : class, IAggregate<TIdentifier> 
+        where TAggregate : class, IAggregate<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
     {
-        private readonly ILogicalTypeRegistry _logicalTypeRegistry;
-        private readonly JsonSerializer _dataSerializer;
-
-        private readonly string _connectionString;
-
         public SqlServerAggregateRepository(ILogicalTypeRegistry logicalTypeRegistry, string connectionString)
+            :base(new SqlServerAggregateRepository(logicalTypeRegistry, connectionString))
         {
-            _logicalTypeRegistry = Guard.NotNull(logicalTypeRegistry, "logicalTypeRegistry");
-            _dataSerializer = JsonSerializerBuilder.Build(logicalTypeRegistry);
-
-            _connectionString = Guard.NotNullOrWhiteSpace(connectionString, "connectionString");
-        }
-
-        protected override async Task<AggregateSnapshotLoadFrame<TIdentifier>> GetSnapshot(TIdentifier id, int maxVersion)
-        {
-            string idString = ConvertIdentifierToString(id);
-
-            using (var connection = new SqlConnection(_connectionString))
-            {
-                await connection.OpenAsync();
-
-                var dbAggregate = await GetAggregate(idString, connection);
-                if (dbAggregate != null)
-                {
-                    Type aggregateType = _logicalTypeRegistry.LookupActualType(
-                        LogicalType.Parse(dbAggregate.Type));
-
-                    var command = new SqlCommand
-                    {
-                        Connection = connection,
-                        CommandType = CommandType.Text,
-                        CommandText = @"SELECT TOP 1 Data
-                                          FROM AggregateSnapshots
-                                         WHERE AggregateId = @pAggregateId 
-                                           AND Version <= @pMaxVersion
-                                      ORDER BY Version DESC"
-                    };
-
-                    command.Parameters.AddWithValue("pAggregateId", idString);
-                    command.Parameters.AddWithValue("pMaxVersion", maxVersion);
-
-                    using (var reader = await command.ExecuteReaderAsync(CommandBehavior.SingleRow))
-                    {
-                        if (await reader.ReadAsync())
-                        {
-                            string data = reader.GetString(reader.GetOrdinal("Data"));
-
-                            var snapshot = _dataSerializer.Deserialize<IAggregateSnapshot<TIdentifier>>(data);
-                            return new AggregateSnapshotLoadFrame<TIdentifier>(aggregateType, id, snapshot);
-                        }
-                    }
-                }
-
-                return null;
-            }
-        }
-
-        protected override async Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(TIdentifier id, int minVersion, int maxVersion)
-        {
-            string idString = ConvertIdentifierToString(id);
-            
-            using (var connection = new SqlConnection(_connectionString))
-            {
-                await connection.OpenAsync();
-                var dbAggregate = await GetAggregate(idString, connection);
-
-                if (dbAggregate != null)
-                {
-                    var dbEvents = await GetAggregateEvents(idString, minVersion, maxVersion, connection);
-
-                    Type aggregateType = _logicalTypeRegistry.LookupActualType(
-                        LogicalType.Parse(dbAggregate.Type));
-
-                    var events = dbEvents
-                        .Select(x => _dataSerializer.Deserialize<IAggregateEvent<TIdentifier>>(x))
-                        .ToArray();
-
-                    return events.Length > 0 
-                        ? new AggregateEventsLoadFrame<TIdentifier>(aggregateType, id, events) 
-                        : null;
-                }
-
-                return null;
-            }
-        }
-
-        protected override async Task SaveSnapshot(AggregateSnapshotSaveFrame<TIdentifier> frame)
-        {
-            string idString = ConvertIdentifierToString(frame.Id);
-            string type = _logicalTypeRegistry.LookupLogicalType(frame.Snapshot.GetType()).ToString();
-
-            using (var connection = new SqlConnection(_connectionString))
-            {
-                await connection.OpenAsync();
-
-                using (var transaction = connection.BeginTransaction())
-                {
-                    if (frame.IsNew)
-                        await SqlServerAggregateRepository.InsertAggregate(connection, transaction, idString, frame.Snapshot.Version, type);
-
-                    var command = new SqlCommand
-                    {
-                        Connection = connection,
-                        Transaction = transaction,
-                        CommandType = CommandType.Text,
-                        CommandText = @"INSERT INTO AggregateSnapshots (AggregateId, Version, Type, Data) VALUES (@pAggregateId, @pVersion, @pType, @pData)"
-                    };
-
-                    command.Parameters.AddWithValue("pAggregateId", idString);
-                    command.Parameters.AddWithValue("pVersion", frame.Snapshot.Version);
-                    command.Parameters.AddWithValue("pType", type);
-                    command.Parameters.AddWithValue("pData", _dataSerializer.Serialize(frame.Snapshot));
-
-                    try
-                    {
-                        int recordsAffected = await command.ExecuteNonQueryAsync();
-                        if (recordsAffected != 1)
-                            throw new AggregateConcurrencyException();
-                    }
-                    catch (SqlException sqlEx)
-                    {
-                        // catch primary key constraint violations - saving snapshot is idempotent
-                        if (sqlEx.Number != 2627)
-                            throw;
-                    }
-
-                    transaction.Commit();
-                }
-            }
-        }
-
-        protected override async Task SaveEvents(AggregateEventsSaveFrame<TIdentifier> frame)
-        {
-            string idString = ConvertIdentifierToString(frame.Id);
-            string type = _logicalTypeRegistry.LookupLogicalType(frame.AggregateType).ToString();
-            var events = frame.Events.ToArray();
-
-            if (events.Length <= 0)
-                throw new ArgumentException("There are no events to save.", "frame");
-
-            using (var connection = new SqlConnection(_connectionString))
-            {
-                await connection.OpenAsync();
-
-                using (var transaction = connection.BeginTransaction(IsolationLevel.Serializable))
-                {
-                    await SqlServerAggregateRepository.UpsertAggregate(connection, transaction, idString, events[0].Version - 1, events[events.Length - 1].Version, type);
-                    await InsertEvents(events, idString, connection, transaction);
-
-                    transaction.Commit();
-                }
-            }
-        }
-
-        private async Task InsertEvents(IEnumerable<IAggregateEvent<TIdentifier>> events, string idString, SqlConnection connection, SqlTransaction transaction)
-        {
-            var dbEvents = events.Select(x => new SqlServerAggregateRepository.DbAggregateEvent(idString,
-                                                                   x.Version,
-                                                                   _logicalTypeRegistry.LookupLogicalType(x.GetType()).ToString(),
-                                                                   _dataSerializer.Serialize(x)))
-                .ToArray();
-
-            foreach (var dbEvent in dbEvents)
-            {
-                int recordsAffected = await InsertEvent(connection, transaction, dbEvent);
-                if (recordsAffected != 1)
-                    throw new AggregateConcurrencyException();
-            }
-        }
-
-        private async Task<int> InsertEvent(SqlConnection connection, SqlTransaction transaction, SqlServerAggregateRepository.DbAggregateEvent @event)
-        {
-            var command = new SqlCommand
-            {
-                Connection = connection,
-                Transaction = transaction,
-                CommandType = CommandType.Text,
-                CommandText = "INSERT INTO AggregateEvents (AggregateId, Version, Type, Data) VALUES(@pAggregateId, @pVersion, @pType, @pData)"
-            };
-
-            command.Parameters.AddWithValue("pAggregateId", @event.AggregateId);
-            command.Parameters.AddWithValue("pVersion", @event.Version);
-            command.Parameters.AddWithValue("pType", @event.Type);
-            command.Parameters.AddWithValue("pData", @event.Data);
-
-            return await command.ExecuteNonQueryAsync();
-        }
-
-        private async Task<SqlServerAggregateRepository.DbAggregate> GetAggregate(string id, SqlConnection connection)
-        {
-            var command = connection.CreateCommand();
-            command.CommandType = CommandType.Text;
-            command.CommandText = @"SELECT Version, Type 
-                                      FROM Aggregates
-                                     WHERE AggregateId = @pAggregateId";
-
-            command.Parameters.AddWithValue("pAggregateId", id);
-
-            using (var reader = await command.ExecuteReaderAsync(CommandBehavior.SingleRow))
-            {
-                if (await reader.ReadAsync())
-                {
-                    int version = reader.GetInt32(reader.GetOrdinal("Version"));
-                    string type = reader.GetString(reader.GetOrdinal("Type"));
-
-                    return new SqlServerAggregateRepository.DbAggregate(id, version, type);
-                }
-
-                return null;
-            }
-        }
-
-        private async Task<String[]> GetAggregateEvents(string id, int minVersion, int maxVersion, SqlConnection connection)
-        {
-            var command = connection.CreateCommand();
-            command.CommandType = CommandType.Text;
-            command.CommandText = @"SELECT Data 
-                                      FROM AggregateEvents 
-                                     WHERE AggregateId = @pAggregateId 
-                                       AND Version >= @pMinVersion
-                                       AND Version <= @pMaxVersion
-                                     ORDER BY Version";
-
-
-            command.Parameters.AddWithValue("pAggregateId", id);
-            command.Parameters.AddWithValue("pMinVersion", minVersion);
-            command.Parameters.AddWithValue("pMaxVersion", maxVersion);
-
-            var results = new List<String>();
-
-            using (var reader = await command.ExecuteReaderAsync(CommandBehavior.SequentialAccess))
-            {
-                while (await reader.ReadAsync())
-                {
-                    string data = reader.GetString(reader.GetOrdinal("Data"));
-
-                    results.Add(data);
-                }
-            }
-
-            return results.ToArray();
-        }
-
-        protected virtual string ConvertIdentifierToString(TIdentifier id)
-        {
-            Guard.NotNull(id, "id");
-            return _dataSerializer.Serialize(id);
         }
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core.UnitTests/LogicalTypeRegistryBuilder.cs b/src/iSynaptic.Core.UnitTests/LogicalTypeRegistryBuilder.cs
index 47bcabe..ab9cd3f 100644
--- a/src/iSynaptic.Core.UnitTests/LogicalTypeRegistryBuilder.cs
+++ b/src/iSynaptic.Core.UnitTests/LogicalTypeRegistryBuilder.cs
@@ -40,8 +40,6 @@ public static LogicalTypeRegistry Build()
 
             registry.AddMapping(new LogicalType("tst", "ServiceCaseId"), typeof(ServiceCaseId));
 
-            registry.AddMapping(new LogicalType("tst", "AggregateMemento.ServiceCaseId"), typeof(AggregateMemento<ServiceCaseId>));
-            registry.AddMapping(new LogicalType("tst", "AggregateMemento.RoleIdentifier"), typeof(AggregateMemento<RoleIdentifier>));
             registry.AddMapping(new LogicalType("tst", "AggregateMemento"), typeof(AggregateMemento));
 
             registry.AddMapping(new LogicalType("tst", "CustomerRoleIdentifier"), typeof(CustomerRoleIdentifier));
diff --git a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateMementoTests.cs b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateMementoTests.cs
index ae5baa9..c204bb3 100644
--- a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateMementoTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateMementoTests.cs
@@ -53,7 +53,7 @@ public void Class_IsJsonSerializable()
                 ServiceCase.SampleContent.CommunicationDuration,
                 ServiceCase.SampleContent.ResponsibleParty);
 
-            var memento = new AggregateMemento<ServiceCaseId>(
+            var memento = new AggregateMemento(
                 typeof (ServiceCase),
                 serviceCase.TakeSnapshot().ToMaybe(),
                 serviceCase.GetEvents());
@@ -61,7 +61,7 @@ public void Class_IsJsonSerializable()
             var serializer = JsonSerializerBuilder.Build(LogicalTypeRegistryBuilder.Build());
 
             String json = serializer.Serialize(memento);
-            var reconstituted = serializer.Deserialize<AggregateMemento<ServiceCaseId>>(json);
+            var reconstituted = serializer.Deserialize<AggregateMemento>(json);
 
             reconstituted.Should().NotBeNull();
             reconstituted.Should().NotBeSameAs(memento);
diff --git a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
index 60359a1..c25d4a8 100644
--- a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
@@ -8,7 +8,7 @@
 
 namespace iSynaptic.Modeling.Domain
 {
-    public abstract class NonGenericAggregateRepositoryTests
+    public abstract class AggregateRepositoryTests
     {
         protected IAggregateRepository Repo { get; set; }
 
@@ -246,7 +246,7 @@ public async Task ConcurrencyConflict_WithFalseConflict_ResolvesConflict()
         }
     }
 
-    public abstract class AggregateRepositoryTests
+    public abstract class GenericAggregateRepositoryTests
     {
         protected IAggregateRepository<ServiceCase, ServiceCaseId> Repo { get; set; }
 
diff --git a/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs
index 7d173a7..2578154 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs
@@ -31,9 +31,9 @@ namespace iSynaptic.Persistence
 {
     [TestFixture]
     [Explicit("Integration tests - requires EventStore to be running locally.")]
-    public class NonGenericEventStoreAggregateRepositoryTests : NonGenericAggregateRepositoryTests
+    public class EventStoreAggregateRepositoryTests : AggregateRepositoryTests
     {
-        public NonGenericEventStoreAggregateRepositoryTests()
+        public EventStoreAggregateRepositoryTests()
         {
             var ltr = LogicalTypeRegistryBuilder.Build();
 
@@ -43,9 +43,9 @@ public NonGenericEventStoreAggregateRepositoryTests()
 
     [TestFixture]
     [Explicit("Integration tests - requires EventStore to be running locally.")]
-    public class EventStoreAggregateRepositoryTests : AggregateRepositoryTests
+    public class EventStoreGenericAggregateRepositoryTests : GenericAggregateRepositoryTests
     {
-        public EventStoreAggregateRepositoryTests()
+        public EventStoreGenericAggregateRepositoryTests()
         {
             var ltr = LogicalTypeRegistryBuilder.Build();
 
diff --git a/src/iSynaptic.Core.UnitTests/Persistence/InMemoryAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/InMemoryAggregateRepositoryTests.cs
index 8f5b6c2..0d64170 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/InMemoryAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/InMemoryAggregateRepositoryTests.cs
@@ -28,18 +28,18 @@
 namespace iSynaptic.Persistence
 {
     [TestFixture]
-    public class NonGenericInMemoryAggregateRepositoryTests : NonGenericAggregateRepositoryTests
+    public class InMemoryAggregateRepositoryTests : AggregateRepositoryTests
     {
-        public NonGenericInMemoryAggregateRepositoryTests()
+        public InMemoryAggregateRepositoryTests()
         {
             Repo = new InMemoryAggregateRepository();
         }
     }
 
     [TestFixture]
-    public class InMemoryAggregateRepositoryTests : AggregateRepositoryTests
+    public class InMemoryGenericAggregateRepositoryTests : GenericAggregateRepositoryTests
     {
-        public InMemoryAggregateRepositoryTests()
+        public InMemoryGenericAggregateRepositoryTests()
         {
             Repo = new InMemoryAggregateRepository<ServiceCase, ServiceCaseId>();
         }
diff --git a/src/iSynaptic.Core.UnitTests/Persistence/InMemoryJsonAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/InMemoryJsonAggregateRepositoryTests.cs
index bb407ed..e1b5b61 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/InMemoryJsonAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/InMemoryJsonAggregateRepositoryTests.cs
@@ -29,18 +29,18 @@
 namespace iSynaptic.Persistence
 {
     [TestFixture]
-    public class NonGenericInMemoryJsonAggregateRepositoryTests : NonGenericAggregateRepositoryTests
+    public class InMemoryJsonAggregateRepositoryTests : AggregateRepositoryTests
     {
-        public NonGenericInMemoryJsonAggregateRepositoryTests()
+        public InMemoryJsonAggregateRepositoryTests()
         {
             Repo = new InMemoryJsonAggregateRepository(JsonSerializerBuilder.Build(LogicalTypeRegistryBuilder.Build()));
         }
     }
 
     [TestFixture]
-    public class InMemoryJsonAggregateRepositoryTests : AggregateRepositoryTests
+    public class InMemoryJsonGenericAggregateRepositoryTests : GenericAggregateRepositoryTests
     {
-        public InMemoryJsonAggregateRepositoryTests()
+        public InMemoryJsonGenericAggregateRepositoryTests()
         {
             Repo = new InMemoryJsonAggregateRepository<ServiceCase, ServiceCaseId>(
                 JsonSerializerBuilder.Build(LogicalTypeRegistryBuilder.Build()));
diff --git a/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs
index a395965..59531c8 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs
@@ -29,11 +29,11 @@ namespace iSynaptic.Persistence
 {
     [TestFixture]
     [Explicit("Integration tests - requires Sql Server to be running locally.")]
-    public class NonGenericSqlServerAggregateRepositoryTests : NonGenericAggregateRepositoryTests
+    public class SqlServerAggregateRepositoryTests : AggregateRepositoryTests
     {
         private const string ConnectionString = "Data Source=.\\sqlexpress;Initial Catalog=AggregateStore;Integrated Security=true;";
 
-        public NonGenericSqlServerAggregateRepositoryTests()
+        public SqlServerAggregateRepositoryTests()
         {
             var ltr = LogicalTypeRegistryBuilder.Build();
 
@@ -49,11 +49,11 @@ public void FixtureSetup()
 
     [TestFixture]
     [Explicit("Integration tests - requires Sql Server to be running locally.")]
-    public class SqlServerAggregateRepositoryTests : AggregateRepositoryTests
+    public class SqlServerGenericAggregateRepositoryTests : GenericAggregateRepositoryTests
     {
         private const string ConnectionString = "Data Source=.\\sqlexpress;Initial Catalog=AggregateStore;Integrated Security=true;";
 
-        public SqlServerAggregateRepositoryTests()
+        public SqlServerGenericAggregateRepositoryTests()
         {
             var ltr = LogicalTypeRegistryBuilder.Build();
 
diff --git a/src/iSynaptic.Core.UnitTests/TestDomain/Generated.cs b/src/iSynaptic.Core.UnitTests/TestDomain/Generated.cs
index 7ea9047..44fb545 100644
--- a/src/iSynaptic.Core.UnitTests/TestDomain/Generated.cs
+++ b/src/iSynaptic.Core.UnitTests/TestDomain/Generated.cs
@@ -227,7 +227,7 @@ public CommunicationRecorded(Int32 threadId, CommunicationDirection direction, S
             [GeneratedCode("iSynaptic.Core", "0.1.23.0")]
             public TimeSpan Duration { get { return _duration; } }
         }
-        public class Snapshot : AggregateSnapshot<ServiceCaseId>
+        public class Snapshot : AggregateSnapshot
         {
             private readonly Int32 _lastThreadId;
             private readonly IEnumerable<CommunicationThreadSnapshot> _threadSnapshots;
diff --git a/src/iSynaptic.Core.UnitTests/TestDomain/ServiceCase.cs b/src/iSynaptic.Core.UnitTests/TestDomain/ServiceCase.cs
index 1659205..b2f712c 100644
--- a/src/iSynaptic.Core.UnitTests/TestDomain/ServiceCase.cs
+++ b/src/iSynaptic.Core.UnitTests/TestDomain/ServiceCase.cs
@@ -84,7 +84,7 @@ protected override void OnInitialize()
             _threads = new List<CommunicationThread>();
         }
 
-        public override IAggregateSnapshot<ServiceCaseId> TakeSnapshot()
+        public override IAggregateSnapshot TakeSnapshot()
         {
             return new Snapshot(_lastThreadId,
                                 _threads.Select(x => new CommunicationThreadSnapshot(x.ThreadId, x.Topic, x.Description)),
diff --git a/src/iSynaptic.Core/Modeling/Domain/Aggregate.cs b/src/iSynaptic.Core/Modeling/Domain/Aggregate.cs
index c1f306f..a2eeb44 100644
--- a/src/iSynaptic.Core/Modeling/Domain/Aggregate.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/Aggregate.cs
@@ -31,7 +31,7 @@ namespace iSynaptic.Modeling.Domain
 {
     internal interface IAggregateInternal
     {
-        void Initialize(IAggregateMemento memento);
+        void Initialize(AggregateMemento memento);
         void ApplyEvents(IEnumerable<IAggregateEvent> events);
         Boolean ConflictsWith(IEnumerable<IAggregateEvent> committedEvents, IEnumerable<IAggregateEvent> attemptedEvents);
         void CommitEvents();
@@ -63,14 +63,14 @@ public abstract class Aggregate<TIdentifier> : IAggregate<TIdentifier>, IAggrega
         private Action<IAggregate<TIdentifier>, IAggregateEvent<TIdentifier>> _eventDispatcher;
 
         [ImmuneToReset]
-        private Action<IAggregate<TIdentifier>, IAggregateSnapshot<TIdentifier>> _snapshotDispatcher;
+        private Action<IAggregate<TIdentifier>, IAggregateSnapshot> _snapshotDispatcher;
 
         protected Aggregate()
         {
             Initialize(null);
         }
 
-        private void Initialize(IAggregateMemento memento)
+        private void Initialize(AggregateMemento memento)
         {
             _events = new AggregateEventStream<TIdentifier>();
 
@@ -82,24 +82,24 @@ private void Initialize(IAggregateMemento memento)
 
             if (memento != null)
             {
-                var m = memento.ToMemento<TIdentifier>();
+                var m = memento;
 
                 if (m.Snapshot.HasValue)
                     ApplySnapshot(m.Snapshot.Value);
 
-                ApplyEventsCore(m.Events);
+                ApplyEventsCore(m.Events.Cast<IAggregateEvent<TIdentifier>>());
                 _events.CommitEvents();
             }
         }
 
-        void IAggregateInternal.Initialize(IAggregateMemento memento)
+        void IAggregateInternal.Initialize(AggregateMemento memento)
         {
-            Initialize(memento.ToMemento<TIdentifier>());
+            Initialize(memento);
         }
 
-        private void ApplySnapshot(IAggregateSnapshot<TIdentifier> snapshot)
+        private void ApplySnapshot(IAggregateSnapshot snapshot)
         {
-            Id = snapshot.Id;
+            Id = (TIdentifier)snapshot.Id;
             Version = snapshot.Version;
 
             DispatchSnapshot(snapshot);
@@ -153,7 +153,7 @@ protected virtual void DispatchEvent(IAggregateEvent<TIdentifier> @event)
             _eventDispatcher(this, @event);
         }
 
-        protected virtual void DispatchSnapshot(IAggregateSnapshot<TIdentifier> snapshot)
+        protected virtual void DispatchSnapshot(IAggregateSnapshot snapshot)
         {
             if(_snapshotDispatcher == null)
                 _snapshotDispatcher = AggregateHelper.GetSnapshotDispatcher<TIdentifier>(GetType());
@@ -162,7 +162,7 @@ protected virtual void DispatchSnapshot(IAggregateSnapshot<TIdentifier> snapshot
         }
 
         protected virtual void OnInitialize() { }
-        public virtual IAggregateSnapshot<TIdentifier> TakeSnapshot() { return null; }
+        public virtual IAggregateSnapshot TakeSnapshot() { return null; }
         public IEnumerable<IAggregateEvent<TIdentifier>> GetEvents() { return _events.Events; }
             
         public IEnumerable<IAggregateEvent<TIdentifier>> GetUncommittedEvents()
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateEventsLoadFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateEventsLoadFrame.cs
index b10a836..25efbc6 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateEventsLoadFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateEventsLoadFrame.cs
@@ -36,16 +36,4 @@ public AggregateEventsLoadFrame(Type aggregateType, object id, IEnumerable<IAggr
 
         public IEnumerable<IAggregateEvent> Events { get; private set; }
     }
-
-    public class AggregateEventsLoadFrame<TIdentifier> : AggregateLoadFrame<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
-    {
-        public AggregateEventsLoadFrame(Type aggregateType, TIdentifier id, IEnumerable<IAggregateEvent<TIdentifier>> events)
-            : base(aggregateType, id)
-        {
-            Events = Guard.NotNull(events, "events");
-        }
-
-        public IEnumerable<IAggregateEvent<TIdentifier>> Events { get; private set; }
-    }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateEventsSaveFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateEventsSaveFrame.cs
index 5e0a9e6..3f94b29 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateEventsSaveFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateEventsSaveFrame.cs
@@ -40,20 +40,4 @@ public AggregateEventsSaveFrame(Type aggregateType, object id, Boolean isNew, In
         public Int32 NewVersion { get; private set; }
         public IEnumerable<IAggregateEvent> Events { get; private set; }
     }
-
-    public class AggregateEventsSaveFrame<TIdentifier> : AggregateSaveFrame<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
-    {
-        public AggregateEventsSaveFrame(Type aggregateType, TIdentifier id, Boolean isNew, Int32 expectedVersion, Int32 newVersion, IEnumerable<IAggregateEvent<TIdentifier>> events)
-            : base (aggregateType, id, isNew)
-        {
-            ExpectedVersion = expectedVersion;
-            NewVersion = newVersion;
-            Events = Guard.NotNull(events, "events");
-        }
-
-        public Int32 ExpectedVersion { get; private set; }
-        public Int32 NewVersion { get; private set; }
-        public IEnumerable<IAggregateEvent<TIdentifier>> Events { get; private set; }
-    }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateHelper.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateHelper.cs
index cd36ed9..e515f2a 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateHelper.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateHelper.cs
@@ -51,10 +51,10 @@ public static Action<IAggregate<TIdentifier>, IAggregateEvent<TIdentifier>> GetE
             return GetDispatcher<IAggregateEvent<TIdentifier>, TIdentifier>(aggregateType, "On", _eventDispatchers);
         }
 
-        public static Action<IAggregate<TIdentifier>, IAggregateSnapshot<TIdentifier>> GetSnapshotDispatcher<TIdentifier>(Type aggregateType)
+        public static Action<IAggregate<TIdentifier>, IAggregateSnapshot> GetSnapshotDispatcher<TIdentifier>(Type aggregateType)
             where TIdentifier : IEquatable<TIdentifier>
         {
-            return GetDispatcher<IAggregateSnapshot<TIdentifier>, TIdentifier>(aggregateType, "Apply", _snapshotDispatchers);
+            return GetDispatcher<IAggregateSnapshot, TIdentifier>(aggregateType, "Apply", _snapshotDispatchers);
         }
 
         private static Action<IAggregate<TIdentifier>, T> GetDispatcher<T, TIdentifier>(Type aggregateType, String methodName, ConcurrentDictionary<Type, Delegate> dictionary)
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateMemento.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateMemento.cs
index f4ea1d4..29733b6 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateMemento.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateMemento.cs
@@ -27,7 +27,7 @@
 
 namespace iSynaptic.Modeling.Domain
 {
-    public sealed class AggregateMemento : IAggregateMemento
+    public sealed class AggregateMemento
     {
         public AggregateMemento(Type aggregateType, Maybe<IAggregateSnapshot> snapshot, IEnumerable<IAggregateEvent> events)
         {
@@ -36,43 +36,8 @@ public AggregateMemento(Type aggregateType, Maybe<IAggregateSnapshot> snapshot,
             Events = events ?? Enumerable.Empty<IAggregateEvent>();
         }
 
-        AggregateMemento<TDesiredIdentifier> IAggregateMemento.ToMemento<TDesiredIdentifier>()
-        {
-            var m = this as AggregateMemento<TDesiredIdentifier>;
-
-            return m ?? new AggregateMemento<TDesiredIdentifier>(AggregateType,
-                Snapshot.Cast<IAggregateSnapshot<TDesiredIdentifier>>(),
-                Events.Cast<IAggregateEvent<TDesiredIdentifier>>()
-            );
-        }
-
         public Type AggregateType { get; private set; }
         public Maybe<IAggregateSnapshot> Snapshot { get; private set; }
         public IEnumerable<IAggregateEvent> Events { get; private set; }
     }
-    
-    public sealed class AggregateMemento<TIdentifier> : IAggregateMemento
-        where TIdentifier : IEquatable<TIdentifier>
-    {
-        public AggregateMemento(Type aggregateType, Maybe<IAggregateSnapshot<TIdentifier>> snapshot, IEnumerable<IAggregateEvent<TIdentifier>> events)
-        {
-            AggregateType = Guard.NotNull(aggregateType, "aggregateType");
-            Snapshot = snapshot;
-            Events = events ?? Enumerable.Empty<IAggregateEvent<TIdentifier>>();
-        }
-
-        AggregateMemento<TDesiredIdentifier> IAggregateMemento.ToMemento<TDesiredIdentifier>()
-        {
-            var m = this as AggregateMemento<TDesiredIdentifier>;
-
-            return m ?? new AggregateMemento<TDesiredIdentifier>(AggregateType,
-                Snapshot.Cast<IAggregateSnapshot<TDesiredIdentifier>>(),
-                Events.Cast<IAggregateEvent<TDesiredIdentifier>>()
-            );
-        }
-
-        public Type AggregateType { get; private set; }
-        public Maybe<IAggregateSnapshot<TIdentifier>> Snapshot { get; private set; }
-        public IEnumerable<IAggregateEvent<TIdentifier>> Events { get; private set; }
-    }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
index 0067bf7..16a8229 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
@@ -31,7 +31,7 @@
 
 namespace iSynaptic.Modeling.Domain
 {
-    public abstract class AggregateRepository : IAggregateRepository
+    public abstract class AggregateRepository : IAggregateRepository, IAggregateRepositoryInternal
     {
         private static readonly Task _completedTask = Task.FromResult(true);
 
@@ -40,16 +40,21 @@ public async Task<IAggregate> Get(Type aggregateType, object id, int maxVersion
             if (!aggregateType.DoesImplementType(typeof(IAggregate)))
                 throw new ArgumentException("AggregateType must implement IAggregate.");
 
+            return await ((IAggregateRepositoryInternal)this).GetCore<IAggregate>(aggregateType, id, maxVersion);
+        }
+
+        async Task<T> IAggregateRepositoryInternal.GetCore<T>(Type aggregateType, object id, int maxVersion)
+        {
             var memento = await GetMemento(id, maxVersion);
 
             if (memento == null)
                 return null;
 
-            var aggregate = (IAggregate)FormatterServices.GetSafeUninitializedObject(aggregateType);
+            var aggregate = (IAggregate) FormatterServices.GetSafeUninitializedObject(memento.AggregateType);
             var ag = AsInternal(aggregate);
             ag.Initialize(memento);
 
-            return aggregate;
+            return (T)aggregate;
         }
 
         public async Task Save(IAggregate aggregate)
@@ -189,148 +194,43 @@ public async Task<AggregateMemento> GetMemento(object id, Int32 maxVersion)
         protected abstract Task SaveEvents(AggregateEventsSaveFrame frame);
     }
 
+    internal interface IAggregateRepositoryInternal
+    {
+        Task<T> GetCore<T>(Type aggregateId, object id, Int32 maxVersion)
+            where T : class, IAggregate;
+    }
+
     public abstract class AggregateRepository<TAggregate, TIdentifier> : IAggregateRepository<TAggregate, TIdentifier> 
         where TAggregate : class, IAggregate<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
     {
-        private static readonly Task _completedTask = Task.FromResult(true);
+        private readonly IAggregateRepository _innerRepository;
+        private readonly IAggregateRepositoryInternal _internalRepository;
 
-        ITask<TAggregate> IAggregateRepositoryQueries<TAggregate, TIdentifier>.Get(TIdentifier id, Int32 maxVersion)
-        {
-            return Get(id, maxVersion).ToCovariantTask();
-        }
-
-        public async Task<TAggregate> Get(TIdentifier id, Int32 maxVersion)
+        protected AggregateRepository(IAggregateRepository innerRepository)
         {
-            var memento = await GetMemento(id, maxVersion);
-
-            if (memento == null)
-                return null;
-
-            var aggregate = (TAggregate)FormatterServices.GetSafeUninitializedObject(memento.AggregateType);
-            var ag = AsInternal(aggregate);
-            ag.Initialize(memento);
-
-            return aggregate;
-        }
-
-        public async Task Save(TAggregate aggregate)
-        {
-            Guard.NotNull(aggregate, "aggregate");
-
-            var ag = AsInternal(aggregate);
-            var aggregateType = aggregate.GetType();
-            var events = aggregate.GetUncommittedEvents().ToArray();
+            _innerRepository = Guard.NotNull(innerRepository, "innerRepository");
+            _internalRepository = innerRepository as IAggregateRepositoryInternal;
 
-            if (events.Length <= 0)
-                return;
-
-            var firstEvent = events[0];
-
-            int saveAttempts = 0;
-            while(true)
+            if (_internalRepository == null)
             {
-                var data = new AggregateEventsSaveFrame<TIdentifier>(aggregateType, aggregate.Id, firstEvent.Version == 1, firstEvent.Version - 1, aggregate.Version, events);
-
-                AggregateConcurrencyException originalException;
-                try
-                {
-                    saveAttempts++;
-
-                    await SaveEvents(data);
-                    break;
-                }
-                catch (AggregateConcurrencyException ace)
-                {
-                    if (saveAttempts == 3)
-                        throw;
-
-                    originalException = ace;
-                }
-                
-                var committedEvents = await GetEvents(aggregate.Id, events[0].Version, Int32.MaxValue);
-                if (ag.ConflictsWith(committedEvents.Events, events))
-                {
-                    throw new AggregateConcurrencyException(originalException.Message,
-                                                            originalException);
-                }
-
-                var newExpectedVersion = committedEvents.Events.Last().Version;
-
-                var memento = await GetMemento(aggregate.Id, newExpectedVersion);
-                ag.Initialize(memento);
-
-                for (int i = 1; i <= events.Length; i++)
-                    ((IAggregateEventInternal)events[i - 1]).Version = newExpectedVersion + i;
-
-                ag.ApplyEvents(events);
+                throw new ArgumentException("Inner IAggregateRepository must implement AggregateRepository.");
             }
-
-            ag.CommitEvents();
-            await OnEventStreamSaved(aggregateType, aggregate.Id, events);
         }
 
-        public async Task SaveSnapshot(TAggregate aggregate)
+        ITask<TAggregate> IAggregateRepositoryQueries<TAggregate, TIdentifier>.Get(TIdentifier id, Int32 maxVersion)
         {
-            Guard.NotNull(aggregate, "aggregate");
-
-            var snapshot = aggregate.TakeSnapshot();
-            if (snapshot == null)
-                throw new ArgumentException("Aggregate doesn't support snapshots.", "aggregate");
-
-            var ag = AsInternal(aggregate);
-            var aggregateType = aggregate.GetType();
-
-            var events = aggregate.GetUncommittedEvents().ToArray();
-            bool isNew = events.Length > 0 && events[0].Version == 1;
-
-            var data = new AggregateSnapshotSaveFrame<TIdentifier>(aggregateType, aggregate.Id, isNew, snapshot);
-            await SaveSnapshot(data);
-
-            await OnSnapshotSaved(aggregateType, snapshot);
+            return _internalRepository.GetCore<TAggregate>(typeof (TAggregate), id, maxVersion).ToCovariantTask();
         }
 
-        private IAggregateInternal AsInternal(TAggregate aggregate)
+        Task IAggregateRepositoryCommands<TAggregate, TIdentifier>.Save(TAggregate aggregate)
         {
-            var ag = aggregate as IAggregateInternal;
-            if(ag == null) throw new InvalidOperationException("Aggregate must inherit from Aggregate<TIdentifier>.");
-            return ag;
+            return _innerRepository.Save(aggregate);
         }
 
-        protected virtual Task OnEventStreamSaved(Type aggregateType, TIdentifier id, IEnumerable<IAggregateEvent<TIdentifier>> events) { return _completedTask; }
-        protected virtual Task OnSnapshotSaved(Type aggregateType, IAggregateSnapshot<TIdentifier> snapshot) { return _completedTask; }
-
-        public async Task<AggregateMemento<TIdentifier>> GetMemento(TIdentifier id, Int32 maxVersion)
+        Task IAggregateRepositoryCommands<TAggregate, TIdentifier>.SaveSnapshot(TAggregate aggregate)
         {
-            var snapshotFrame = await GetSnapshot(id, maxVersion);
-            if (snapshotFrame != null)
-            {
-                var snapshot = snapshotFrame.Snapshot;
-                var events = Enumerable.Empty<IAggregateEvent<TIdentifier>>();
-                
-                if (snapshot.Version < maxVersion)
-                {
-                    var eventsFrame = await GetEvents(id, snapshot.Version + 1, maxVersion);
-                    if(eventsFrame != null)
-                        events = eventsFrame.Events;
-                }
-
-                return new AggregateMemento<TIdentifier>(snapshotFrame.AggregateType, snapshot.ToMaybe(), events);
-            }
-            else
-            {
-                var eventsFrame = await GetEvents(id, 1, maxVersion);
-
-                return eventsFrame != null 
-                    ? new AggregateMemento<TIdentifier>(eventsFrame.AggregateType, Maybe.NoValue, eventsFrame.Events)
-                    : null;
-            }
+            return _innerRepository.SaveSnapshot(aggregate);
         }
-
-        protected abstract Task<AggregateSnapshotLoadFrame<TIdentifier>> GetSnapshot(TIdentifier id, Int32 maxVersion);
-        protected abstract Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(TIdentifier id, Int32 minVersion, Int32 maxVersion);
-
-        protected abstract Task SaveSnapshot(AggregateSnapshotSaveFrame<TIdentifier> frame);
-        protected abstract Task SaveEvents(AggregateEventsSaveFrame<TIdentifier> frame);
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshot.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshot.cs
index 1d6f97d..04cd900 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshot.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshot.cs
@@ -25,10 +25,9 @@
 namespace iSynaptic.Modeling.Domain
 {
     [Serializable]
-    public abstract class AggregateSnapshot<TIdentifier> : IAggregateSnapshot<TIdentifier>, IAggregateSnapshot
-        where TIdentifier : IEquatable<TIdentifier>
+    public abstract class AggregateSnapshot : IAggregateSnapshot
     {
-        protected AggregateSnapshot(TIdentifier id, Int32 version, DateTime takenAt)
+        protected AggregateSnapshot(object id, Int32 version, DateTime takenAt)
         {
             if (version <= 0)
                 throw new ArgumentOutOfRangeException("version", "Version must be greater than 0.");
@@ -43,8 +42,7 @@ protected AggregateSnapshot(TIdentifier id, Int32 version, DateTime takenAt)
         }
 
         public Guid SnapshotId { get; private set; }
-        public TIdentifier Id { get; private set; }
-        object IAggregateSnapshot.Id { get { return ((IAggregateSnapshot<TIdentifier>) this).Id; }}
+        public object Id { get; private set; }
         public Int32 Version { get; private set; }
         public DateTime TakenAt { get; private set; }
     }
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotLoadFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotLoadFrame.cs
index 66fc186..e24913e 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotLoadFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotLoadFrame.cs
@@ -35,16 +35,4 @@ public AggregateSnapshotLoadFrame(Type aggregateType, object id, IAggregateSnaps
 
         public IAggregateSnapshot Snapshot { get; private set; }
     }
-
-    public class AggregateSnapshotLoadFrame<TIdentifier> : AggregateLoadFrame<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
-    {
-        public AggregateSnapshotLoadFrame(Type aggregateType, TIdentifier id, IAggregateSnapshot<TIdentifier> snapshot)
-            : base(aggregateType, id)
-        {
-            Snapshot = Guard.NotNull(snapshot, "snapshot");
-        }
-
-        public IAggregateSnapshot<TIdentifier> Snapshot { get; private set; }
-    }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotSaveFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotSaveFrame.cs
index d7de688..34eec3e 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotSaveFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotSaveFrame.cs
@@ -35,16 +35,4 @@ public AggregateSnapshotSaveFrame(Type aggregateType, object id, Boolean isNew,
 
         public IAggregateSnapshot Snapshot { get; private set; }
     }
-
-    public class AggregateSnapshotSaveFrame<TIdentifier> : AggregateSaveFrame<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
-    {
-        public AggregateSnapshotSaveFrame(Type aggregateType, TIdentifier id, Boolean isNew, IAggregateSnapshot<TIdentifier> snapshot)
-            : base(aggregateType, id, isNew)
-        {
-            Snapshot = Guard.NotNull(snapshot, "snapshot");
-        }
-
-        public IAggregateSnapshot<TIdentifier> Snapshot { get; private set; }
-    }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/IAggregate.cs b/src/iSynaptic.Core/Modeling/Domain/IAggregate.cs
index d78fda8..9a4dd51 100644
--- a/src/iSynaptic.Core/Modeling/Domain/IAggregate.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/IAggregate.cs
@@ -14,14 +14,11 @@ public interface IAggregate
         IAggregateSnapshot TakeSnapshot();
     }
 
-    public interface IAggregate<out TIdentifier> 
+    public interface IAggregate<out TIdentifier> : IAggregate 
         where TIdentifier : IEquatable<TIdentifier>
     {
-        TIdentifier Id { get; }
-        Int32 Version { get; }
+        new TIdentifier Id { get; }
 
-        IEnumerable<IAggregateEvent<TIdentifier>> GetUncommittedEvents();
-
-        IAggregateSnapshot<TIdentifier> TakeSnapshot();
+        new IEnumerable<IAggregateEvent<TIdentifier>> GetUncommittedEvents();
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/IAggregateMemento.cs b/src/iSynaptic.Core/Modeling/Domain/IAggregateMemento.cs
deleted file mode 100644
index 46414b2..0000000
--- a/src/iSynaptic.Core/Modeling/Domain/IAggregateMemento.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// The MIT License
-// 
-// Copyright (c) 2013 Jordan E. Terrell
-// 
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// 
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-using System;
-
-namespace iSynaptic.Modeling.Domain
-{
-    internal interface IAggregateMemento
-    {
-        AggregateMemento<TIdentifier> ToMemento<TIdentifier>()
-            where TIdentifier : IEquatable<TIdentifier>;
-    }
-}
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/IAggregateSnapshot.cs b/src/iSynaptic.Core/Modeling/Domain/IAggregateSnapshot.cs
index a36e23c..6583944 100644
--- a/src/iSynaptic.Core/Modeling/Domain/IAggregateSnapshot.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/IAggregateSnapshot.cs
@@ -33,10 +33,4 @@ public interface IAggregateSnapshot
 
         DateTime TakenAt { get; }
     }
-
-    public interface IAggregateSnapshot<out TIdentifier> : IAggregateSnapshot
-        where TIdentifier : IEquatable<TIdentifier>
-    {
-        new TIdentifier Id { get; }
-    }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/iSynaptic.Core.csproj b/src/iSynaptic.Core/iSynaptic.Core.csproj
index 5d7b3a4..6fd0d7e 100644
--- a/src/iSynaptic.Core/iSynaptic.Core.csproj
+++ b/src/iSynaptic.Core/iSynaptic.Core.csproj
@@ -75,7 +75,6 @@
     <Compile Include="Modeling\Domain\AggregateSnapshotSaveFrame.cs" />
     <Compile Include="Modeling\Domain\IAggregate.cs" />
     <Compile Include="Modeling\Domain\IAggregateEvent.cs" />
-    <Compile Include="Modeling\Domain\IAggregateMemento.cs" />
     <Compile Include="Modeling\Domain\IAggregateRepository.cs" />
     <Compile Include="Modeling\Domain\IAggregateSnapshot.cs" />
     <Compile Include="Modeling\Domain\ImmuneToResetAttribute.cs" />

From 3a46961c2bca1984294fa7866c287a3c66fbcad5 Mon Sep 17 00:00:00 2001
From: Bill Biwer <bill.biwer@young-america.com>
Date: Wed, 20 May 2015 15:03:18 -0500
Subject: [PATCH 6/6] Reverted integration test changes for connection string
 and ES address

---
 .../Persistence/EventStoreAggregateRepositoryTests.cs         | 4 ++--
 .../Persistence/SqlServerAggregateRepositoryTests.cs          | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs
index 2578154..c2c7cdf 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs
@@ -37,7 +37,7 @@ public EventStoreAggregateRepositoryTests()
         {
             var ltr = LogicalTypeRegistryBuilder.Build();
 
-            Repo = new EventStoreAggregateRepository(ltr, () => EventStoreConnection.Create(new IPEndPoint(IPAddress.Parse("10.8.80.11"), 1113)));
+            Repo = new EventStoreAggregateRepository(ltr, () => EventStoreConnection.Create(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113)));
         }
     }
 
@@ -49,7 +49,7 @@ public EventStoreGenericAggregateRepositoryTests()
         {
             var ltr = LogicalTypeRegistryBuilder.Build();
 
-            Repo = new EventStoreAggregateRepository<ServiceCase, ServiceCaseId>(ltr, () => EventStoreConnection.Create(new IPEndPoint(IPAddress.Parse("10.8.80.11"), 1113)));
+            Repo = new EventStoreAggregateRepository<ServiceCase, ServiceCaseId>(ltr, () => EventStoreConnection.Create(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113)));
         }
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs
index 59531c8..653d560 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs
@@ -31,7 +31,7 @@ namespace iSynaptic.Persistence
     [Explicit("Integration tests - requires Sql Server to be running locally.")]
     public class SqlServerAggregateRepositoryTests : AggregateRepositoryTests
     {
-        private const string ConnectionString = "Data Source=.\\sqlexpress;Initial Catalog=AggregateStore;Integrated Security=true;";
+        private const string ConnectionString = "Data Source=(local);Initial Catalog=AggregateStore;Integrated Security=true;";
 
         public SqlServerAggregateRepositoryTests()
         {
@@ -51,7 +51,7 @@ public void FixtureSetup()
     [Explicit("Integration tests - requires Sql Server to be running locally.")]
     public class SqlServerGenericAggregateRepositoryTests : GenericAggregateRepositoryTests
     {
-        private const string ConnectionString = "Data Source=.\\sqlexpress;Initial Catalog=AggregateStore;Integrated Security=true;";
+        private const string ConnectionString = "Data Source=(local);Initial Catalog=AggregateStore;Integrated Security=true;";
 
         public SqlServerGenericAggregateRepositoryTests()
         {