feat: allow synchronous mode to be specified for non-test mode

important for void transactions if you immediately want the current state

Author: the-avid-engineer

src/EntityDb.Common/Transactions/SnapshottingTransactionSubscriber.cs

@@ -8,16 +8,16 @@
 
 namespace EntityDb.Common.Transactions
 {
-    internal class SnapshottingTransactionSubscriber<TEntity> : AsyncTransactionSubscriber<TEntity>
+    internal class SnapshottingTransactionSubscriber<TEntity> : TransactionSubscriber<TEntity>
     {
         private readonly ISnapshotRepositoryFactory<TEntity> _snapshotRepositoryFactory;
         private readonly ISnapshotSessionOptions _snapshotSessionOptions = new SnapshotSessionOptions();
 
         public SnapshottingTransactionSubscriber
         (
             ISnapshotRepositoryFactory<TEntity> snapshotRepositoryFactory,
-            bool testMode
-        ) : base(testMode)
+            bool synchronous
+        ) : base(synchronous)
         {
             _snapshotRepositoryFactory = snapshotRepositoryFactory;
         }
@@ -39,10 +39,10 @@ protected override async Task NotifyAsync(ITransaction<TEntity> transaction)
             }
         }
 
-        public static SnapshottingTransactionSubscriber<TEntity> Create(IServiceProvider serviceProvider, bool testMode)
+        public static SnapshottingTransactionSubscriber<TEntity> Create(IServiceProvider serviceProvider, bool synchronousMode)
         {
             return ActivatorUtilities.CreateInstance<SnapshottingTransactionSubscriber<TEntity>>(serviceProvider,
-                testMode);
+                synchronousMode);
         }
     }
 }

…ansactions/AsyncTransactionSubscriber.cs …on/Transactions/TransactionSubscriber.cssrc/EntityDb.Common/Transactions/AsyncTransactionSubscriber.cs renamed to src/EntityDb.Common/Transactions/TransactionSubscriber.cs src/EntityDb.Common/Transactions/AsyncTransactionSubscriber.cs renamed to src/EntityDb.Common/Transactions/TransactionSubscriber.cs

@@ -1,38 +1,38 @@
-using EntityDb.Abstractions.Transactions;
-using System.Threading.Tasks;
-
-namespace EntityDb.Common.Transactions
-{
-    /// <summary>
-    ///     Represents an asynchronous subscription to transactions.
-    /// </summary>
-    /// <typeparam name="TEntity"></typeparam>
-    public abstract class AsyncTransactionSubscriber<TEntity> : ITransactionSubscriber<TEntity>
-    {
-        private readonly bool _testMode;
-
-        /// <summary>
-        ///     Constructs a new instance of <see cref="AsyncTransactionSubscriber{TEntity}" />.
-        /// </summary>
-        /// <param name="testMode">If <c>true</c> then the task will be synchronously awaited before returning.</param>
-        protected AsyncTransactionSubscriber(bool testMode)
-        {
-            _testMode = testMode;
-        }
-
-        /// <inheritdoc cref="ITransactionSubscriber{TEntity}.Notify(ITransaction{TEntity})" />
-        public void Notify(ITransaction<TEntity> transaction)
-        {
-            var task = Task.Run(() => NotifyAsync(transaction));
-
-            if (_testMode)
-            {
-                task.Wait();
-            }
-        }
-
-        /// <inheritdoc cref="ITransactionSubscriber{TEntity}.Notify(ITransaction{TEntity})"/>
-        /// <returns>A task that handles notification asynchronously.</returns>
-        protected abstract Task NotifyAsync(ITransaction<TEntity> transaction);
-    }
-}
+using EntityDb.Abstractions.Transactions;
+using System.Threading.Tasks;
+
+namespace EntityDb.Common.Transactions
+{
+    /// <summary>
+    ///     Represents an asynchronous subscription to transactions.
+    /// </summary>
+    /// <typeparam name="TEntity"></typeparam>
+    public abstract class TransactionSubscriber<TEntity> : ITransactionSubscriber<TEntity>
+    {
+        private readonly bool _synchronousMode;
+
+        /// <summary>
+        ///     Constructs a new instance of <see cref="TransactionSubscriber{TEntity}" />.
+        /// </summary>
+        /// <param name="synchronousMode">If <c>true</c> then the task will be synchronously awaited before returning.</param>
+        protected TransactionSubscriber(bool synchronousMode)
+        {
+            _synchronousMode = synchronousMode;
+        }
+
+        /// <inheritdoc cref="ITransactionSubscriber{TEntity}.Notify(ITransaction{TEntity})" />
+        public void Notify(ITransaction<TEntity> transaction)
+        {
+            var task = Task.Run(async () => await NotifyAsync(transaction).ConfigureAwait(false));
+
+            if (_synchronousMode)
+            {
+                task.Wait();
+            }
+        }
+
+        /// <inheritdoc cref="ITransactionSubscriber{TEntity}.Notify(ITransaction{TEntity})"/>
+        /// <returns>A task that handles notification asynchronously.</returns>
+        protected abstract Task NotifyAsync(ITransaction<TEntity> transaction);
+    }
+}

src/EntityDb.Redis/Extensions/IServiceCollectionExtensions.cs

@@ -22,18 +22,19 @@ public static class IServiceCollectionExtensions
         /// <param name="serviceCollection">The service collection.</param>
         /// <param name="keyNamespace">The namespace used to build a Redis key.</param>
         /// <param name="getConnectionString">A function that retrieves the Redis connection string.</param>
+        /// <param name="synchronousMode">If <c>true</c> then snapshots will be synchronously recorded.</param>
         /// <remarks>
         ///     The production-ready implementation will store snapshots as they come in. If you need write an integration test,
         ///     consider using
-        ///     <see cref="AddTestModeRedisSnapshots{TEntity}(IServiceCollection, string, Func{IConfiguration, string})" />
+        ///     <see cref="AddTestModeRedisSnapshots{TEntity}(IServiceCollection, string, Func{IConfiguration, string}, bool)" />
         ///     instead.
         /// </remarks>
         [ExcludeFromCodeCoverage(Justification = "Tests use TestMode.")]
         public static void AddRedisSnapshots<TEntity>(this IServiceCollection serviceCollection, string keyNamespace,
-            Func<IConfiguration, string> getConnectionString)
+            Func<IConfiguration, string> getConnectionString, bool synchronousMode = false)
         {
             serviceCollection.AddSingleton<ITransactionSubscriber<TEntity>>(serviceProvider =>
-                SnapshottingTransactionSubscriber<TEntity>.Create(serviceProvider, false));
+                SnapshottingTransactionSubscriber<TEntity>.Create(serviceProvider, synchronousMode));
 
             serviceCollection.AddSingleton<ISnapshotRepositoryFactory<TEntity>>(serviceProvider =>
             {
@@ -55,15 +56,16 @@ public static void AddRedisSnapshots<TEntity>(this IServiceCollection serviceCol
         /// <param name="serviceCollection">The service collection.</param>
         /// <param name="keyNamespace">The namespace used to build a Redis key.</param>
         /// <param name="getConnectionString">A function that retrieves the Redis connection string.</param>
+        /// <param name="synchronousMode">If <c>true</c> then snapshots will be synchronously recorded.</param>
         /// <remarks>
         ///     The test-mode implementation will store snapshots as they come in, but the snapshots will be automatically removed
         ///     when the repository is disposed.
         /// </remarks>
         public static void AddTestModeRedisSnapshots<TEntity>(this IServiceCollection serviceCollection,
-            string keyNamespace, Func<IConfiguration, string> getConnectionString)
+            string keyNamespace, Func<IConfiguration, string> getConnectionString, bool synchronousMode = true)
         {
             serviceCollection.AddSingleton<ITransactionSubscriber<TEntity>>(serviceProvider =>
-                SnapshottingTransactionSubscriber<TEntity>.Create(serviceProvider, true));
+                SnapshottingTransactionSubscriber<TEntity>.Create(serviceProvider, synchronousMode));
 
             serviceCollection.AddSingleton<ISnapshotRepositoryFactory<TEntity>>(serviceProvider =>
             {