ManualFrameProvider

sandbox/ConsoleApp1/Program.cs

@@ -1,6 +1,7 @@
 using Microsoft.Extensions.Logging;
 using R3;
 using R3.Internal;
+using System.Diagnostics;
 using System.Reactive;
 using System.Reactive.Concurrency;
 using System.Reactive.Linq;
@@ -44,21 +45,35 @@
 
 
 
-source.DoOnDisposed(() => {/*Console.WriteLine("DISPOSED")*/}).WriteLine();
+source.DoOnDisposed(() => { Console.WriteLine("DISPOSED"); }).WriteLine();
+
+SubscriptionTracker.ForEachActiveTask(x =>
+{
+    Console.WriteLine(x);
+});
+
 
 
+Console.WriteLine("BeforeId:" + Thread.CurrentThread.ManagedThreadId);
 
-// TODO: if WaitAsync is using, not disposed???
 await source.WaitAsync();
 Console.WriteLine("Press Key to done.");
 
+
+await Task.Yield();
+
 Console.ReadLine();
 
+
 SubscriptionTracker.ForEachActiveTask(x =>
 {
     Console.WriteLine(x);
 });
 
+Console.WriteLine("----------------");
+Console.WriteLine("AfterId:" + Thread.CurrentThread.ManagedThreadId);
+
+
 public static class Extensions
 {
     public static IDisposable WriteLine<T>(this Event<T> source)

src/R3/FrameProvider.cs

@@ -2,18 +2,70 @@
 
 public abstract class FrameProvider
 {
-    protected event Action<Exception>? UnhandledException;
     public abstract long GetFrameCount();
     public abstract void Register(IFrameRunnerWorkItem callback);
-
-    protected void OnUnhandledException(Exception ex)
-    {
-        UnhandledException?.Invoke(ex);
-    }
 }
 
 public interface IFrameRunnerWorkItem
 {
     // true, continue
     bool MoveNext(long frameCount);
 }
+
+public sealed class ManualFrameProvider : FrameProvider
+{
+    long frameCount;
+    FreeListCore<IFrameRunnerWorkItem> list = new FreeListCore<IFrameRunnerWorkItem>();
+
+    public override long GetFrameCount()
+    {
+        return frameCount;
+    }
+
+    public override void Register(IFrameRunnerWorkItem callback)
+    {
+        list.Add(callback);
+    }
+
+    public void Advance()
+    {
+        Advance(1);
+    }
+
+    public void Advance(int advanceCount)
+    {
+        for (int i = 0; i < advanceCount; i++)
+        {
+            RunLoop();
+        }
+    }
+
+    void RunLoop()
+    {
+        var span = list.AsSpan();
+        for (int i = 0; i < span.Length; i++)
+        {
+            ref readonly var item = ref span[i];
+            if (item != null)
+            {
+                try
+                {
+                    if (!item.MoveNext(frameCount))
+                    {
+                        list.Remove(i);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    list.Remove(i);
+                    try
+                    {
+                        EventSystem.GetUnhandledExceptionHandler().Invoke(ex);
+                    }
+                    catch { }
+                }
+            }
+        }
+        frameCount++;
+    }
+}

src/R3/Operators/DoOnDisposed.cs

@@ -16,9 +16,7 @@ public static Event<T> DoOnDisposed<T, TState>(this Event<T> source, Action<TSta
     }
 }
 
-
-
-internal sealed class DoOnDisposed<T>(Event<T> source, Action action) : Event<T>
+sealed class DoOnDisposed<T>(Event<T> source, Action action) : Event<T>
 {
     protected override IDisposable SubscribeCore(Subscriber<T> subscriber)
     {

src/R3/ThreadSleepFrameProvider.cs

@@ -61,7 +61,7 @@ void Run()
                         list.Remove(i);
                         try
                         {
-                            OnUnhandledException(ex);
+                            EventSystem.GetUnhandledExceptionHandler().Invoke(ex);
                         }
                         catch { }
                     }