refactor to have features

DUI3/Speckle.Connectors.DUI/Eventing/DelegateReference.cs

@@ -10,13 +10,17 @@ public class DelegateReference
   private readonly MethodInfo _method;
   private readonly Type? _delegateType;
 
-  public DelegateReference(Delegate @delegate, bool isAsync)
+  public DelegateReference(Delegate @delegate, EventFeatures features)
   {
     var target = @delegate.Target;
     _method = @delegate.Method;
     if (target != null)
     {
-      if (Attribute.IsDefined(_method.DeclaringType.NotNull(), typeof(CompilerGeneratedAttribute)))
+      //anonymous methods are always strong....should we do this? - doing a brief search says yes
+      if (
+        features.HasFlag(EventFeatures.ForceStrongReference)
+        || Attribute.IsDefined(_method.DeclaringType.NotNull(), typeof(CompilerGeneratedAttribute))
+      )
       {
         _weakReference = WeakOrStrongReference.CreateStrong(target);
       }
@@ -26,7 +30,7 @@ public DelegateReference(Delegate @delegate, bool isAsync)
       }
 
       var messageType = @delegate.Method.GetParameters()[0].ParameterType;
-      if (isAsync)
+      if (features.HasFlag(EventFeatures.IsAsync))
       {
         _delegateType = typeof(Func<,>).MakeGenericType(messageType, typeof(Task));
       }

DUI3/Speckle.Connectors.DUI/Eventing/EventFeatures.cs

@@ -0,0 +1,11 @@
+// ReSharper disable InconsistentNaming
+namespace Speckle.Connectors.DUI.Eventing;
+
+[Flags]
+public enum EventFeatures
+{
+  None = 0,
+  OneTime = 1,
+  IsAsync = 2,
+  ForceStrongReference = 4
+}

DUI3/Speckle.Connectors.DUI/Eventing/EventSubscription.cs

@@ -1,17 +1,21 @@
-using Speckle.Connectors.DUI.Bridge;
+using Speckle.Connectors.Common.Threading;
+using Speckle.Connectors.DUI.Bridge;
 
 namespace Speckle.Connectors.DUI.Eventing;
 
 public class EventSubscription<TPayload>(
   DelegateReference actionReference,
+  IThreadContext threadContext,
   ITopLevelExceptionHandler exceptionHandler,
-  SubscriptionToken token
+  SubscriptionToken token,
+  ThreadOption threadOption,
+  EventFeatures features
 ) : IEventSubscription
   where TPayload : notnull
 {
   public SubscriptionToken SubscriptionToken => token;
 
-  public virtual Func<object[], Task>? GetExecutionStrategy()
+  public Func<object[], Task>? GetExecutionStrategy()
   {
     if (!actionReference.IsAlive)
     {
@@ -24,6 +28,29 @@ SubscriptionToken token
     };
   }
 
-  public virtual async Task InvokeAction(TPayload argument) =>
+  private async Task InvokeAction(TPayload argument)
+  {
+    switch (threadOption)
+    {
+      case ThreadOption.MainThread:
+        await threadContext.RunOnMainAsync(() => Invoke(argument));
+        break;
+      case ThreadOption.WorkerThread:
+        await threadContext.RunOnWorkerAsync(() => Invoke(argument));
+        break;
+      case ThreadOption.PublisherThread:
+      default:
+        await Invoke(argument);
+        break;
+    }
+  }
+
+  private async Task Invoke(TPayload argument)
+  {
     await exceptionHandler.CatchUnhandledAsync(() => actionReference.Invoke(argument));
+    if (features.HasFlag(EventFeatures.OneTime))
+    {
+      SubscriptionToken.Dispose();
+    }
+  }
 }

DUI3/Speckle.Connectors.DUI/Eventing/OneTimeThreadedEvent.cs

@@ -44,7 +44,7 @@ public SubscriptionToken OneTimeSubscribe(
         }
         _activeTokens.Remove(id);
       }
-      token = SubscribeOnceOrNot(action, threadOption, true);
+      token = Subscribe(action, threadOption, EventFeatures.OneTime);
       _activeTokens.Add(id, token);
       return token;
     }
@@ -71,7 +71,7 @@ public SubscriptionToken OneTimeSubscribe(
         }
         _activeTokens.Remove(id);
       }
-      token = SubscribeOnceOrNot(action, threadOption, true);
+      token = Subscribe(action, threadOption, EventFeatures.OneTime);
       _activeTokens.Add(id, token);
       return token;
     }

DUI3/Speckle.Connectors.DUI/Eventing/SpeckleEvent.cs

@@ -13,51 +13,28 @@ public abstract class SpeckleEvent<T>(IThreadContext threadContext, ITopLevelExc
 
   public virtual Task PublishAsync(T payload) => InternalPublish(payload);
 
-  protected SubscriptionToken SubscribeOnceOrNot(Func<T, Task> action, ThreadOption threadOption, bool isOnce)
+  protected SubscriptionToken Subscribe(Func<T, Task> action, ThreadOption threadOption, EventFeatures features)
   {
-    var actionReference = new DelegateReference(action, true);
-    return SubscribeOnceOrNot(actionReference, threadOption, isOnce);
+    features |= EventFeatures.IsAsync;
+    var actionReference = new DelegateReference(action, features);
+    return Subscribe(actionReference, threadOption, features);
   }
 
-  protected SubscriptionToken SubscribeOnceOrNot(Action<T> action, ThreadOption threadOption, bool isOnce)
+  protected SubscriptionToken Subscribe(Action<T> action, ThreadOption threadOption, EventFeatures features)
   {
-    var actionReference = new DelegateReference(action, false);
-    return SubscribeOnceOrNot(actionReference, threadOption, isOnce);
+    var actionReference = new DelegateReference(action, features);
+    return Subscribe(actionReference, threadOption, features);
   }
 
   [SuppressMessage("Reliability", "CA2000:Dispose objects before losing scope")]
-  private SubscriptionToken SubscribeOnceOrNot(
+  private SubscriptionToken Subscribe(
     DelegateReference actionReference,
     ThreadOption threadOption,
-    bool isOnce
+    EventFeatures features
   )
   {
-    EventSubscription<T> subscription;
-    switch (threadOption)
-    {
-      case ThreadOption.WorkerThread:
-        subscription = new WorkerEventSubscription<T>(
-          actionReference,
-          threadContext,
-          exceptionHandler,
-          new(Unsubscribe),
-          isOnce
-        );
-        break;
-      case ThreadOption.MainThread:
-        subscription = new MainThreadEventSubscription<T>(
-          actionReference,
-          threadContext,
-          exceptionHandler,
-          new(Unsubscribe),
-          isOnce
-        );
-        break;
-      case ThreadOption.PublisherThread:
-      default:
-        subscription = new OneTimeEventSubscription<T>(actionReference, exceptionHandler, new(Unsubscribe), isOnce);
-        break;
-    }
+    EventSubscription<T> subscription =
+      new(actionReference, threadContext, exceptionHandler, new(Unsubscribe), threadOption, features);
     return InternalSubscribe(subscription);
   }
 }

DUI3/Speckle.Connectors.DUI/Eventing/ThreadedEvent.cs

@@ -8,8 +8,8 @@ public abstract class ThreadedEvent<T>(IThreadContext threadContext, ITopLevelEx
   where T : notnull
 {
   public SubscriptionToken Subscribe(Func<T, Task> action, ThreadOption threadOption = ThreadOption.PublisherThread) =>
-    SubscribeOnceOrNot(action, threadOption, false);
+    Subscribe(action, threadOption, EventFeatures.None);
 
   public SubscriptionToken Subscribe(Action<T> action, ThreadOption threadOption = ThreadOption.PublisherThread) =>
-    SubscribeOnceOrNot(action, threadOption, false);
+    Subscribe(action, threadOption, EventFeatures.None);
 }