From 9de4b27003c70d135a5a2b36e033a353a742e292 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Thu, 8 Jan 2026 10:27:47 -0500 Subject: [PATCH] refactor: Ensure stream subscriptions only disposed once In the debugger, I noticed a few streams were unhooking their internal onChange callbacks unnecessarily (when they were already unhooked). --- .../DataStream/Primitives/Map/MapStream.cs | 9 ++- .../Primitives/Union/MutableAppendStream.cs | 70 +++++++++++-------- .../DataStreamCore/DataStream.cs | 7 +- .../DataStreamCore/ViewStreamExtensions.cs | 23 ++++++ 4 files changed, 74 insertions(+), 35 deletions(-) create mode 100644 src/DataStreamSuite/DataStreamCore/ViewStreamExtensions.cs diff --git a/src/DataStreamSuite/DataStream/Primitives/Map/MapStream.cs b/src/DataStreamSuite/DataStream/Primitives/Map/MapStream.cs index 28d54ce5c..0a7e54e2b 100644 --- a/src/DataStreamSuite/DataStream/Primitives/Map/MapStream.cs +++ b/src/DataStreamSuite/DataStream/Primitives/Map/MapStream.cs @@ -1,9 +1,7 @@ using bts; -using Bts.DataStream; using Bts.DataStreamCore; -using mbts.config; using mbts.utils; using System; @@ -22,6 +20,7 @@ namespace BCG { protected IStreamMapper? myMapper; protected IChangeableStreamMapper? myChangeableMapper; private bool myUseNewMap = false; + IDisposable? subscription; public class FuncWrapper : IStreamMapper { private Func _schema_map_func; @@ -118,13 +117,13 @@ namespace BCG { protected override void myOnFirstSubscriber() { - myStream.onChange += new DataStream.ChangeDelegate(myChangeHandler); + subscription = myStream.Subscribe(myChangeHandler); } protected override void myOnLastSubscriber() { myInit(); - if (myStream != null) - myStream.onChange -= new DataStream.ChangeDelegate(myChangeHandler); + subscription?.Dispose(); + subscription = null; } protected override void myOnTableClear() { diff --git a/src/DataStreamSuite/DataStream/Primitives/Union/MutableAppendStream.cs b/src/DataStreamSuite/DataStream/Primitives/Union/MutableAppendStream.cs index da8f236e0..eeb849691 100644 --- a/src/DataStreamSuite/DataStream/Primitives/Union/MutableAppendStream.cs +++ b/src/DataStreamSuite/DataStream/Primitives/Union/MutableAppendStream.cs @@ -1,8 +1,10 @@ +using bts; + +using Bts.DataStreamCore; + using System; using System.Collections.Generic; - -using mbts; -//using BCG; +using System.Collections.Immutable; namespace BCG { /// @@ -171,7 +173,8 @@ namespace BCG { private MutableAppendTable myTable; private int myMovingIndex; bool isFirstUpdate = true; - private Dictionary> myStreamIndex = new Dictionary>(); + ImmutableDictionary myStreamIndex = + ImmutableDictionary.Empty; private bool _allign_col_orders = true; public MutableAppendStream(params ViewStream[] streams) @@ -186,13 +189,15 @@ namespace BCG { public MutableAppendStream(bool allign_col_orders, ICollection streams) { _allign_col_orders = allign_col_orders; + var streamIndexBd = myStreamIndex.ToBuilder(); foreach (ViewStream vs in streams) { myMovingIndex++; ViewStream pj = new ChangeTableNameStream(vs, myMovingIndex.ToString()); if (_allign_col_orders) pj = new ProjectStream(pj, "!"); - myStreamIndex.Add(myMovingIndex, new Pair(vs, pj)); + streamIndexBd.Add(myMovingIndex, (vs, pj, null)); } + myStreamIndex = streamIndexBd.ToImmutable(); } public void addStream(ViewStream vs) { @@ -202,41 +207,50 @@ namespace BCG { ViewStream pj = new ChangeTableNameStream(vs, myMovingIndex.ToString()); if (_allign_col_orders) pj = new ProjectStream(pj, "!"); - myStreamIndex.Add(myMovingIndex, new Pair(vs, pj)); - if (mySubscriptionActive) - pj.onChange += new ChangeDelegate(myHandleStreamChanges); + IDisposable? sub = null; + if (mySubscriptionActive) { + sub = pj.Subscribe(myHandleStreamChanges); + } + myStreamIndex = myStreamIndex.Add(myMovingIndex, (vs, pj, sub)); } public void removeStream(ViewStream vs) { - int index = -1; - foreach (KeyValuePair> p in myStreamIndex) { - if (p.Value.first == vs) { - index = p.Key; - if (mySubscriptionActive) { - p.Value.second.onChange -= new ChangeDelegate(myHandleStreamChanges); - if (myTable != null) { - IBlueRowCollection delRows = myTable.removeTable(p.Key); - if (delRows != null) - myFireEvent(new DataPacket(myTable, new BlueTable(myTable.schema), delRows)); - } - } - break; - } - if (index > 0) - myStreamIndex.Remove(index); + if (!myStreamIndex.TryGetFirst(kvp => kvp.Value.Input == vs, out var kvp)) { + return; } + var (input, _, sub) = kvp.Value; + if (mySubscriptionActive) { + sub?.Dispose(); + if (myTable != null) { + IBlueRowCollection delRows = myTable.removeTable(kvp.Key); + if (delRows != null) + myFireEvent(new DataPacket(myTable, new BlueTable(myTable.schema), delRows)); + } + } + myStreamIndex = myStreamIndex.Remove(kvp.Key); } protected override void myOnFirstSubscriber() { mySubscriptionActive = true; - foreach (KeyValuePair> p in myStreamIndex) - p.Value.second.onChange += new ChangeDelegate(myHandleStreamChanges); + isFirstUpdate = true; + var streamIndexBd = myStreamIndex.ToBuilder(); + foreach (var (index, streamTup) in myStreamIndex) { + var (input, output, sub) = streamTup; + Log.isnull(sub); + streamIndexBd[index] = (input, output, output.Subscribe(myHandleStreamChanges)); + } + myStreamIndex = streamIndexBd.ToImmutable(); } protected override void myOnLastSubscriber() { mySubscriptionActive = false; - foreach (KeyValuePair> p in myStreamIndex) - p.Value.second.onChange -= new ChangeDelegate(myHandleStreamChanges); + var streamIndexBd = myStreamIndex.ToBuilder(); + foreach (var (index, streamTup) in myStreamIndex) { + var (input, output, sub) = streamTup; + sub?.Dispose(); + streamIndexBd[index] = (input, output, null); + } + myStreamIndex = streamIndexBd.ToImmutable(); if (myTable != null) myTable.clear(); } diff --git a/src/DataStreamSuite/DataStreamCore/DataStream.cs b/src/DataStreamSuite/DataStreamCore/DataStream.cs index 3d80bd605..05cf10a24 100644 --- a/src/DataStreamSuite/DataStreamCore/DataStream.cs +++ b/src/DataStreamSuite/DataStreamCore/DataStream.cs @@ -102,8 +102,11 @@ namespace BCG myRealSource.onChange -= currValue; else { - myOnChangeDelegate = - (ChangeDelegate) Delegate.Remove (myOnChangeDelegate,currValue); + if (myOnChangeDelegate is null) { + Log.DataFlow.warn("Attempted to remove DataStream callback called when change delegate already null"); + } else { + myOnChangeDelegate = (ChangeDelegate)Delegate.Remove(myOnChangeDelegate, currValue); + } // this is need to avoid a callback in a reentrant add. if (myPendingAdds.Count > 0) diff --git a/src/DataStreamSuite/DataStreamCore/ViewStreamExtensions.cs b/src/DataStreamSuite/DataStreamCore/ViewStreamExtensions.cs new file mode 100644 index 000000000..156f75132 --- /dev/null +++ b/src/DataStreamSuite/DataStreamCore/ViewStreamExtensions.cs @@ -0,0 +1,23 @@ +#nullable enable +namespace Bts.DataStreamCore; + +using BCG; + +using mbts.utils; + +using Spark.Core.Disposables; + +using System; + +public static class ViewStreamExtensions { + public static IDisposable Subscribe(this ViewStream viewStream, Action onData) { + viewStream.onChange += OnChange; + return Disposable.Create(Unsubscribe); + + void OnChange(object? obj) => + onData(ExceptionAssert.Argument.Is(obj)); + + void Unsubscribe() => + viewStream.onChange -= OnChange; + } +}