* Also wrap start/stop work in suppress scope

* refactor transaction scope wrapper

Author: Jann Roder

Winton.Extensions.Threading.Actor/ActorExtensions.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Transactions;
 
 namespace Winton.Extensions.Threading.Actor
 {
@@ -30,15 +31,15 @@ public static IActor WithStartWork(this IActor self, ActorStartWork work)
         /// <param name="self">Actor</param>
         /// <param name="work">Work to do.</param>
         /// <returns>Actor</returns>
-        public static IActor WithStartWork(this IActor self, Action work) => self.WithStartWork(new ActorStartWork(work));
+        public static IActor WithStartWork(this IActor self, Action work) => self.WithStartWork(new ActorStartWork(SuppressTransactionScopeWrapper(work)));
 
         /// <summary>
         /// Specify work for actor start-up.
         /// </summary>
         /// <param name="self">Actor</param>
         /// <param name="work">Async work to do.</param>
         /// <returns>Actor</returns>
-        public static IActor WithStartWork(this IActor self, Func<Task> work) => self.WithStartWork(new ActorStartWork(work));
+        public static IActor WithStartWork(this IActor self, Func<Task> work) => self.WithStartWork(new ActorStartWork(SuppressTransactionScopeWrapper(work)));
 
         /// <summary>
         /// Specify work for actor start-up.
@@ -52,7 +53,7 @@ public static IActor WithStopWork(this IActor self, ActorStopWork work)
             return self;
         }
 
-        public static IActor WithStopWork(this IActor self, Action work) => self.WithStopWork(new ActorStopWork(work));
+        public static IActor WithStopWork(this IActor self, Action work) => self.WithStopWork(new ActorStopWork(SuppressTransactionScopeWrapper(work)));
 
         /// <summary>
         /// Enqueue a procedure.
@@ -184,5 +185,45 @@ public static CancellationToken StoppedToken(this IActor self)
 
             return cancellationTokenSource.Token;
         }
+
+        internal static Func<T> SuppressTransactionScopeWrapper<T>(Func<T> function)
+        {
+            return () =>
+            {
+                using (var scope = new TransactionScope(
+                    TransactionScopeOption.Suppress,
+                    TransactionScopeAsyncFlowOption.Enabled))
+                {
+                    try
+                    {
+                        return function();
+                    }
+                    finally
+                    {
+                        scope.Complete();
+                    }
+                }
+            };
+        }
+
+        internal static Action SuppressTransactionScopeWrapper(Action action)
+        {
+            return () =>
+            {
+                using (var scope = new TransactionScope(
+                    TransactionScopeOption.Suppress,
+                    TransactionScopeAsyncFlowOption.Enabled))
+                {
+                    try
+                    {
+                        action();
+                    }
+                    finally
+                    {
+                        scope.Complete();
+                    }
+                }
+            };
+        }
     }
 }

Winton.Extensions.Threading.Actor/Internal/ActorTaskFactory.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Transactions;
 
 namespace Winton.Extensions.Threading.Actor.Internal
 {
@@ -18,22 +17,7 @@ public Task StartNew(Action action, CancellationToken cancellationToken, TaskCre
             ActorTask.CurrentActorTaskTraits = traits;
             ActorTask.CurrentCanceller = cancellationTokenSource;
 
-            void TransactionScopeWrapper(Action theAction)
-            {
-                using (var scope = new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled))
-                {
-                    try
-                    {
-                        theAction();
-                    }
-                    finally
-                    {
-                        scope.Complete();
-                    }
-                }
-            }
-
-            return Task.Factory.StartNew(() => TransactionScopeWrapper(action), cancellationTokenSource.Token, taskCreationOptions | TaskCreationOptions.HideScheduler, _scheduler);
+            return Task.Factory.StartNew(ActorExtensions.SuppressTransactionScopeWrapper(action), cancellationTokenSource.Token, taskCreationOptions | TaskCreationOptions.HideScheduler, _scheduler);
         }
 
         public Task<T> StartNew<T>(Func<T> function, CancellationToken cancellationToken, TaskCreationOptions taskCreationOptions, ActorTaskTraits traits = ActorTaskTraits.None)
@@ -43,22 +27,7 @@ public Task<T> StartNew<T>(Func<T> function, CancellationToken cancellationToken
             ActorTask.CurrentActorTaskTraits = traits;
             ActorTask.CurrentCanceller = cancellationTokenSource;
 
-            T TransactionScopeWrapper(Func<T> theFunction)
-            {
-                using (var scope = new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled))
-                {
-                    try
-                    {
-                        return theFunction();
-                    }
-                    finally
-                    {
-                        scope.Complete();
-                    }
-                }
-            }
-
-            return Task.Factory.StartNew(() => TransactionScopeWrapper(function), cancellationTokenSource.Token, taskCreationOptions | TaskCreationOptions.HideScheduler, _scheduler);
+            return Task.Factory.StartNew(ActorExtensions.SuppressTransactionScopeWrapper(function), cancellationTokenSource.Token, taskCreationOptions | TaskCreationOptions.HideScheduler, _scheduler);
         }
     }
 }