Added weak-referencing to operators using background scheduling, to ensure that schedulers do not leak the operator subscriptions. (#1027)

Author: JakenVeina

src/DynamicData/Cache/Internal/ExpireAfter.ForSource.cs

@@ -204,11 +204,15 @@ private void OnExpirationsChanged()
                         _nextScheduledManagement = new()
                         {
                             Cancellation = _scheduler.Schedule(
-                                state: this,
+                                state: new WeakReference<SubscriptionBase>(this),
                                 dueTime: nextManagementDueTime,
-                                action: static (_, @this) =>
+                                action: static (_, thisReference) =>
                                 {
-                                    @this.ManageExpirations();
+                                    // Most schedulers won't clear scheduled actions upon cancellation, they'll wait until they were supposed to occur.
+                                    // A WeakReference here prevents the whole subscription from memory leaking
+                                    // Refer to https://github.com/reactivemarbles/DynamicData/issues/1025
+                                    if (thisReference.TryGetTarget(out var @this))
+                                        @this.ManageExpirations();
 
                                     return Disposable.Empty;
                                 }),

src/DynamicData/Cache/Internal/ExpireAfter.ForStream.cs

@@ -182,11 +182,15 @@ private void OnExpirationsChanged()
                         _nextScheduledManagement = new()
                         {
                             Cancellation = _scheduler.Schedule(
-                                state: this,
+                                state: new WeakReference<SubscriptionBase>(this),
                                 dueTime: nextManagementDueTime,
-                                action: (_, @this) =>
+                                action: (_, thisReference) =>
                                 {
-                                    @this.ManageExpirations();
+                                    // Most schedulers won't clear scheduled actions upon cancellation, they'll wait until they were supposed to occur.
+                                    // A WeakReference here prevents the whole subscription from memory leaking
+                                    // Refer to https://github.com/reactivemarbles/DynamicData/issues/1025
+                                    if (thisReference.TryGetTarget(out var @this))
+                                        @this.ManageExpirations();
 
                                     return Disposable.Empty;
                                 }),

src/DynamicData/Cache/Internal/ToObservableChangeSet.cs

@@ -114,9 +114,7 @@ public void Dispose()
             _scheduledExpiration?.Cancellation.Dispose();
         }
 
-        private IDisposable OnScheduledExpirationInvoked(
-            IScheduler scheduler,
-            Expiration intendedExpiration)
+        private IDisposable OnScheduledExpirationInvoked(Expiration intendedExpiration)
         {
             try
             {
@@ -256,9 +254,20 @@ private void FinishSchedulingExpiration(
                 ScheduledExpiration unfinishedExpiration,
                 IScheduler scheduler)
             => unfinishedExpiration.Cancellation.Disposable = scheduler.Schedule(
-                state: unfinishedExpiration.Expiration,
+                state: (
+                    thisReference: new WeakReference<Subscription>(this),
+                    expiration: unfinishedExpiration.Expiration),
                 dueTime: unfinishedExpiration.Expiration.ExpireAt,
-                action: OnScheduledExpirationInvoked);
+                action: static (_, state) =>
+                {
+                    // Most schedulers won't clear scheduled actions upon cancellation, they'll wait until they were supposed to occur.
+                    // A WeakReference here prevents the whole subscription from memory leaking
+                    // Refer to https://github.com/reactivemarbles/DynamicData/issues/1025
+                    if (state.thisReference.TryGetTarget(out var @this))
+                        @this.OnScheduledExpirationInvoked(state.expiration);
+
+                    return Disposable.Empty;
+                });
 
         private void TryPublishCompletion()
         {

src/DynamicData/List/Internal/ExpireAfter.cs

@@ -197,11 +197,15 @@ private void OnExpirationDueTimesChanged()
                     _nextScheduledManagement = new()
                     {
                         Cancellation = _scheduler.Schedule(
-                            state: this,
+                            state: new WeakReference<SubscriptionBase>(this),
                             dueTime: nextManagementDueTime,
-                            action: (_, @this) =>
+                            action: (_, thisReference) =>
                             {
-                                @this.ManageExpirations();
+                                // Most schedulers won't clear scheduled actions upon cancellation, they'll wait until they were supposed to occur.
+                                // A WeakReference here prevents the whole subscription from memory leaking
+                                // Refer to https://github.com/reactivemarbles/DynamicData/issues/1025
+                                if (thisReference.TryGetTarget(out var @this))
+                                    @this.ManageExpirations();
 
                                 return Disposable.Empty;
                             }),

src/DynamicData/List/Internal/ToObservableChangeSet.cs

@@ -110,9 +110,7 @@ public void Dispose()
             _scheduledExpiration?.Cancellation.Dispose();
         }
 
-        private IDisposable OnScheduledExpirationInvoked(
-            IScheduler scheduler,
-            Expiration intendedExpiration)
+        private IDisposable OnScheduledExpirationInvoked(Expiration intendedExpiration)
         {
             try
             {
@@ -290,9 +288,20 @@ private void FinishSchedulingExpiration(
                 ScheduledExpiration unfinishedExpiration,
                 IScheduler scheduler)
             => unfinishedExpiration.Cancellation.Disposable = scheduler.Schedule(
-                state: unfinishedExpiration.Expiration,
+                state: (
+                    thisReference: new WeakReference<Subscription>(this),
+                    expiration: unfinishedExpiration.Expiration),
                 dueTime: unfinishedExpiration.Expiration.ExpireAt,
-                action: OnScheduledExpirationInvoked);
+                action: static (_, state) =>
+                {
+                    // Most schedulers won't clear scheduled actions upon cancellation, they'll wait until they were supposed to occur.
+                    // A WeakReference here prevents the whole subscription from memory leaking
+                    // Refer to https://github.com/reactivemarbles/DynamicData/issues/1025
+                    if (state.thisReference.TryGetTarget(out var @this))
+                        @this.OnScheduledExpirationInvoked(state.expiration);
+
+                    return Disposable.Empty;
+                });
 
         private void TryPublishCompletion()
         {