Removed some useless locks on signal property change observable

fedeAlterio · web-flow · commit 85aa0920f8bf · 2025-12-14T18:22:00.000+01:00
diff --git a/SignalsDotnet/SignalsDotnet/Helpers/Optional.cs b/SignalsDotnet/SignalsDotnet/Helpers/Optional.cs
@@ -1,4 +1,5 @@
 ﻿using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 
 namespace SignalsDotnet.Helpers;
 
@@ -14,9 +15,11 @@ public readonly struct Optional<T>
 
 public static class OptionalExtensions
 {
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool TryGetValue<T>(this Optional<T> @this, [NotNullWhen(true)] out T? value)
     {
-        value = @this.HasValue ? @this.Value : default;
-        return @this.HasValue;
+        var hasValue = @this.HasValue;
+        value = hasValue ? @this.Value : default;
+        return hasValue;
     }
 }
diff --git a/SignalsDotnet/SignalsDotnet/Internals/ComputedObservable.cs b/SignalsDotnet/SignalsDotnet/Internals/ComputedObservable.cs
@@ -4,7 +4,7 @@
 
 namespace SignalsDotnet.Internals;
 
-internal class ComputedObservable<T> : Observable<T>
+internal sealed class ComputedObservable<T> : Observable<T>
 {
     readonly Func<CancellationToken, ValueTask<T>> _func;
     readonly Func<Optional<T>> _fallbackValue;
@@ -24,7 +24,7 @@ public ComputedObservable(Func<CancellationToken, ValueTask<T>> func,
 
     protected override IDisposable SubscribeCore(Observer<T> observer) => new Subscription(this, observer);
 
-    class Subscription : IDisposable
+    sealed class Subscription : IDisposable
     {
         readonly ComputedObservable<T> _observable;
         readonly Observer<T> _observer;
@@ -45,9 +45,9 @@ async void WatchSignalsChanges()
                 try
                 {
                     var token = _disposed.Token;
-                    while (!token.IsCancellationRequested)
+                    do
                     {
-                        var result = await ComputeResult(_disposed.Token);
+                        var result = await ComputeResult(token);
                         if (token.IsCancellationRequested) return;
 
                         if (result.ResultOptional.TryGetValue(out var propertyValue))
@@ -58,7 +58,7 @@ async void WatchSignalsChanges()
                         await using var _ = token.Register(static x => ((SyncCompletionSource)x!).SetCompleted(Unit.Default), result.SignalChangedAwaitable);
                         await result.SignalChangedAwaitable;
                         _disconnectSubscription.Dispose();
-                    }
+                    } while (!token.IsCancellationRequested);
                 }
                 finally
                 {
@@ -74,8 +74,7 @@ async void WatchSignalsChanges()
 
         async ValueTask<ComputationResult> ComputeResult(CancellationToken cancellationToken)
         {
-            var referenceEquality = ReferenceEqualityComparer.Instance;
-            HashSet<IReadOnlySignal> signalRequested = new(referenceEquality);
+            var signalsRequested = new HashSet<IReadOnlySignal>(ReferenceEqualityComparer.Instance);
             Optional<T> result;
 
             _disconnectSubscription = new();
@@ -97,7 +96,7 @@ async ValueTask<ComputationResult> ComputeResult(CancellationToken cancellationT
             var signalRequestedSubscription = Signal.SignalsRequested()
                                                     .Subscribe(signal =>
                                                     {
-                                                        if (!signalRequested.Add(signal)) return;
+                                                        if (!signalsRequested.Add(signal)) return;
 
                                                         signal.FutureValues.Subscribe(_ =>
                                                         {
@@ -159,8 +158,8 @@ public void Dispose()
         }
     }
 
-    record struct ComputationResult(SyncCompletionSource SignalChangedAwaitable, Optional<T> ResultOptional);
-    class SyncCompletionSource : INotifyCompletion
+    readonly record struct ComputationResult(SyncCompletionSource SignalChangedAwaitable, Optional<T> ResultOptional);
+    sealed class SyncCompletionSource : INotifyCompletion
     {
         Action? _continuation;
         public SyncCompletionSource GetAwaiter() => this;
@@ -184,7 +183,7 @@ public void GetResult() {}
     }
 }
 
-internal class ActionStub
+internal sealed class ActionStub
 {
     public static readonly Action Nop = () => { };
 }
diff --git a/SignalsDotnet/SignalsDotnet/Internals/ComputedSignalrFactory/DefaultComputedSignalFactory.cs b/SignalsDotnet/SignalsDotnet/Internals/ComputedSignalrFactory/DefaultComputedSignalFactory.cs
@@ -4,7 +4,7 @@
 
 namespace SignalsDotnet.Internals.ComputedSignalrFactory;
 
-internal class DefaultComputedSignalFactory : IComputedSignalFactory
+internal sealed class DefaultComputedSignalFactory : IComputedSignalFactory
 {
     public IReadOnlySignal<T> Computed<T>(Func<T> func, Func<Optional<T>> fallbackValue, ReadonlySignalConfigurationDelegate<T?>? configuration = null)
     {
diff --git a/SignalsDotnet/SignalsDotnet/Internals/ComputedSignalrFactory/OnErrorComputedSignalFactoryDecorator.cs b/SignalsDotnet/SignalsDotnet/Internals/ComputedSignalrFactory/OnErrorComputedSignalFactoryDecorator.cs
@@ -5,27 +5,16 @@
 
 namespace SignalsDotnet.Internals.ComputedSignalrFactory;
 
-internal class OnErrorComputedSignalFactoryDecorator : IComputedSignalFactory
+internal sealed class OnErrorComputedSignalFactoryDecorator(IComputedSignalFactory parent, bool ignoreOperationCancelled, Action<Exception> onException) : IComputedSignalFactory
 {
-    readonly IComputedSignalFactory _parent;
-    readonly bool _ignoreOperationCancelled;
-    readonly Action<Exception> _onException;
-
-    public OnErrorComputedSignalFactoryDecorator(IComputedSignalFactory parent, bool ignoreOperationCancelled, Action<Exception> onException)
-    {
-        _parent = parent;
-        _ignoreOperationCancelled = ignoreOperationCancelled;
-        _onException = onException;
-    }
-
     public IReadOnlySignal<T> Computed<T>(Func<T> func, Func<Optional<T>> fallbackValue, ReadonlySignalConfigurationDelegate<T?>? configuration = null)
     {
         return ComputedObservable(func, fallbackValue).ToSignal(configuration!);
     }
 
     public Observable<T> ComputedObservable<T>(Func<T> func, Func<Optional<T>> fallbackValue)
     {
-        return _parent.ComputedObservable(() =>
+        return parent.ComputedObservable(() =>
         {
             try
             {
@@ -47,7 +36,7 @@ public IAsyncReadOnlySignal<T> AsyncComputed<T>(Func<CancellationToken, ValueTas
 
     public Observable<T> AsyncComputedObservable<T>(Func<CancellationToken, ValueTask<T>> func, T startValue, Func<Optional<T>> fallbackValue, ConcurrentChangeStrategy concurrentChangeStrategy = default)
     {
-        return _parent.AsyncComputedObservable(async token =>
+        return parent.AsyncComputedObservable(async token =>
         {
             try
             {
@@ -63,7 +52,7 @@ public Observable<T> AsyncComputedObservable<T>(Func<CancellationToken, ValueTas
 
     public ISignal<T> Linked<T>(Func<T> func, Func<Optional<T>> fallbackValue, ReadonlySignalConfigurationDelegate<T?>? configuration = null)
     {
-        return _parent.Linked(() =>
+        return parent.Linked(() =>
         {
             try
             {
@@ -83,7 +72,7 @@ public IAsyncSignal<T> AsyncLinked<T>(Func<CancellationToken, ValueTask<T>> func
                                           ConcurrentChangeStrategy concurrentChangeStrategy = default,
                                           ReadonlySignalConfigurationDelegate<T>? configuration = null)
     {
-        return _parent.AsyncLinked(async token =>
+        return parent.AsyncLinked(async token =>
         {
             try
             {
@@ -99,7 +88,7 @@ public IAsyncSignal<T> AsyncLinked<T>(Func<CancellationToken, ValueTask<T>> func
 
     public Effect Effect(Action onChange, TimeProvider? scheduler = null)
     {
-        return _parent.Effect(() =>
+        return parent.Effect(() =>
         {
             try
             {
@@ -115,7 +104,7 @@ public Effect Effect(Action onChange, TimeProvider? scheduler = null)
 
     public Effect AsyncEffect(Func<CancellationToken, ValueTask> onChange, ConcurrentChangeStrategy concurrentChangeStrategy = default, TimeProvider? scheduler = null)
     {
-        return _parent.AsyncEffect(async token =>
+        return parent.AsyncEffect(async token =>
         {
             try
             {
@@ -131,11 +120,14 @@ public Effect AsyncEffect(Func<CancellationToken, ValueTask> onChange, Concurren
 
     void NotifyException(Exception e)
     {
-        if (_ignoreOperationCancelled && e is OperationCanceledException)
+        if (ignoreOperationCancelled && e is OperationCanceledException)
         {
             return;
         }
 
-        Signal.Untracked(() => _onException(e));
+        using (Signal.UntrackedScope())
+        {
+            onException(e);
+        }
     }
 }
diff --git a/SignalsDotnet/SignalsDotnet/Internals/Helpers/KeyEqualityComparer.cs b/SignalsDotnet/SignalsDotnet/Internals/Helpers/KeyEqualityComparer.cs
@@ -1,22 +1,17 @@
 ﻿namespace SignalsDotnet.Internals.Helpers;
 
-internal class KeyEqualityComparer<T, TDestination> : IEqualityComparer<T> where TDestination : notnull
+internal sealed class KeyEqualityComparer<T, TDestination>(Func<T?, TDestination> keyExtractor) : IEqualityComparer<T>
+    where TDestination : notnull
 {
-    readonly Func<T?, TDestination> _keyExtractor;
     readonly EqualityComparer<TDestination> _equalityComparer = EqualityComparer<TDestination>.Default;
 
-    public KeyEqualityComparer(Func<T?, TDestination> keyExtractor)
-    {
-        _keyExtractor = keyExtractor;
-    }
-
     public bool Equals(T? x, T? y)
     {
-        return _equalityComparer.Equals(_keyExtractor(x), _keyExtractor(y));
+        return _equalityComparer.Equals(keyExtractor(x), keyExtractor(y));
     }
 
     public int GetHashCode(T? obj)
     {
-        return _equalityComparer.GetHashCode(_keyExtractor(obj));
+        return _equalityComparer.GetHashCode(keyExtractor(obj));
     }
 }
diff --git a/SignalsDotnet/SignalsDotnet/Internals/Helpers/ObservableFromINotifyCollectionChanged.cs b/SignalsDotnet/SignalsDotnet/Internals/Helpers/ObservableFromINotifyCollectionChanged.cs
@@ -10,14 +10,9 @@ internal static class ObservableFromINotifyCollectionChanged
         return new CollectionChangedObservable(collection);
     }
 
-    class CollectionChangedObservable : Observable<(object? sender, NotifyCollectionChangedEventArgs e)>
+    sealed class CollectionChangedObservable(INotifyCollectionChanged notifyCollectionChanged) : Observable<(object? sender, NotifyCollectionChangedEventArgs e)>
     {
-        readonly INotifyCollectionChanged _notifyCollectionChanged;
-
-        public CollectionChangedObservable(INotifyCollectionChanged notifyCollectionChanged)
-        {
-            _notifyCollectionChanged = notifyCollectionChanged;
-        }
+        readonly INotifyCollectionChanged _notifyCollectionChanged = notifyCollectionChanged;
 
         protected override IDisposable SubscribeCore(Observer<(object? sender, NotifyCollectionChangedEventArgs e)> observer)
         {
diff --git a/SignalsDotnet/SignalsDotnet/Internals/Helpers/ObservableFromPropertyChanged.cs b/SignalsDotnet/SignalsDotnet/Internals/Helpers/ObservableFromPropertyChanged.cs
@@ -15,29 +15,21 @@ public static FromPropertyChangedObservableUnit OnPropertyChangedAsUnit<T>(this
         return new FromPropertyChangedObservableUnit(@this, futureChangesOnly);
     }
 
-    public class FromPropertyChangedObservableUnit : Observable<Unit>
+    public class FromPropertyChangedObservableUnit(IReadOnlySignal signal, bool futureChangesOnly) : Observable<Unit>
     {
-        readonly IReadOnlySignal _signal;
-        readonly bool _futureChangesOnly;
-
-        public FromPropertyChangedObservableUnit(IReadOnlySignal signal, bool futureChangesOnly)
-        {
-            _signal = signal;
-            _futureChangesOnly = futureChangesOnly;
-        }
+        readonly IReadOnlySignal _signal = signal;
+        readonly bool _futureChangesOnly = futureChangesOnly;
 
         protected override IDisposable SubscribeCore(Observer<Unit> observer)
         {
             return new FromPropertyChangedSubscriptionUnit(observer, this);
         }
 
 
-        class FromPropertyChangedSubscriptionUnit : IDisposable
+        sealed class FromPropertyChangedSubscriptionUnit : IDisposable
         {
             readonly Observer<Unit> _observer;
             readonly FromPropertyChangedObservableUnit _observable;
-            readonly object _locker = new();
-            bool _isDisposed;
 
             public FromPropertyChangedSubscriptionUnit(Observer<Unit> observer, FromPropertyChangedObservableUnit observable)
             {
@@ -50,64 +42,30 @@ public FromPropertyChangedSubscriptionUnit(Observer<Unit> observer, FromProperty
                 }
 
                 _observer.OnNext(Unit.Default);
-                lock (_locker)
-                {
-                    if (_isDisposed)
-                    {
-                        return;
-                    }
-
-                    observable._signal.PropertyChanged += OnPropertyChanged;
-                }
+                observable._signal.PropertyChanged += OnPropertyChanged;
             }
 
-            void OnPropertyChanged(object? sender, PropertyChangedEventArgs e)
-            {
-                _observer.OnNext(Unit.Default);
-            }
-
-            public void Dispose()
-            {
-                if (!_observable._futureChangesOnly)
-                {
-                    lock (_locker)
-                    {
-                        if (_isDisposed)
-                            return;
-
-                        _isDisposed = true;
-                    }
-                }
-
-                _observable._signal.PropertyChanged -= OnPropertyChanged;
-            }
+            void OnPropertyChanged(object? sender, PropertyChangedEventArgs e) => _observer.OnNext(Unit.Default);
+            public void Dispose() => _observable._signal.PropertyChanged -= OnPropertyChanged;
         }
     }
 
 
-    public class FromPropertyChangedObservable<T> : Observable<T>
+    public class FromPropertyChangedObservable<T>(IReadOnlySignal<T> signal, bool futureChangesOnly) : Observable<T>
     {
-        readonly IReadOnlySignal<T> _signal;
-        readonly bool _futureChangesOnly;
-
-        public FromPropertyChangedObservable(IReadOnlySignal<T> signal, bool futureChangesOnly)
-        {
-            _signal = signal;
-            _futureChangesOnly = futureChangesOnly;
-        }
+        readonly IReadOnlySignal<T> _signal = signal;
+        readonly bool _futureChangesOnly = futureChangesOnly;
 
         protected override IDisposable SubscribeCore(Observer<T> observer)
         {
             return new FromPropertyChangedSubscription(observer, this);
         }
 
 
-        class FromPropertyChangedSubscription : IDisposable
+        sealed class FromPropertyChangedSubscription : IDisposable
         {
             readonly Observer<T> _observer;
             readonly FromPropertyChangedObservable<T> _observable;
-            readonly object _locker = new();
-            bool _isDisposed;
 
             public FromPropertyChangedSubscription(Observer<T> observer, FromPropertyChangedObservable<T> observable)
             {
@@ -120,37 +78,12 @@ public FromPropertyChangedSubscription(Observer<T> observer, FromPropertyChanged
                 }
 
                 _observer.OnNext(_observable._signal.Value);
-                lock (_locker)
-                {
-                    if (_isDisposed)
-                    {
-                        return;
-                    }
-
-                    observable._signal.PropertyChanged += OnPropertyChanged;
-                }
-            }
-
-            void OnPropertyChanged(object? sender, PropertyChangedEventArgs e)
-            {
-                _observer.OnNext(_observable._signal.Value);
+                observable._signal.PropertyChanged += OnPropertyChanged;
             }
 
-            public void Dispose()
-            {
-                if (!_observable._futureChangesOnly)
-                {
-                    lock (_locker)
-                    {
-                        if (_isDisposed)
-                            return;
-
-                        _isDisposed = true;
-                    }
-                }
+            void OnPropertyChanged(object? sender, PropertyChangedEventArgs e) => _observer.OnNext(_observable._signal.Value);
 
-                _observable._signal.PropertyChanged -= OnPropertyChanged;
-            }
+            public void Dispose() => _observable._signal.PropertyChanged -= OnPropertyChanged;
         }
     }
 }
diff --git a/SignalsDotnet/SignalsDotnet/Internals/Helpers/WeakObservable.cs b/SignalsDotnet/SignalsDotnet/Internals/Helpers/WeakObservable.cs
diff --git a/SignalsDotnet/SignalsDotnet/Signal.cs b/SignalsDotnet/SignalsDotnet/Signal.cs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System.Diagnostics.CodeAnalysis;`
	`2`	`+using System.Runtime.CompilerServices;`
`2`	`3`
`3`	`4`	`namespace SignalsDotnet.Helpers;`
`4`	`5`
`@@ -14,9 +15,11 @@ public readonly struct Optional<T>`
`14`	`15`
`15`	`16`	`public static class OptionalExtensions`
`16`	`17`	`{`
	`18`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
`17`	`19`	`public static bool TryGetValue<T>(this Optional<T> @this, [NotNullWhen(true)] out T? value)`
`18`	`20`	`{`
`19`		`- value = @this.HasValue ? @this.Value : default;`
`20`		`- return @this.HasValue;`
	`21`	`+ var hasValue = @this.HasValue;`
	`22`	`+ value = hasValue ? @this.Value : default;`
	`23`	`+ return hasValue;`
`21`	`24`	`}`
`22`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`namespace SignalsDotnet.Internals;`
`6`	`6`
`7`		`-internal class ComputedObservable<T> : Observable<T>`
	`7`	`+internal sealed class ComputedObservable<T> : Observable<T>`
`8`	`8`	`{`
`9`	`9`	`readonly Func<CancellationToken, ValueTask<T>> _func;`
`10`	`10`	`readonly Func<Optional<T>> _fallbackValue;`
`@@ -24,7 +24,7 @@ public ComputedObservable(Func<CancellationToken, ValueTask<T>> func,`
`24`	`24`
`25`	`25`	`protected override IDisposable SubscribeCore(Observer<T> observer) => new Subscription(this, observer);`
`26`	`26`
`27`		`- class Subscription : IDisposable`
	`27`	`+ sealed class Subscription : IDisposable`
`28`	`28`	`{`
`29`	`29`	`readonly ComputedObservable<T> _observable;`
`30`	`30`	`readonly Observer<T> _observer;`
`@@ -45,9 +45,9 @@ async void WatchSignalsChanges()`
`45`	`45`	`try`
`46`	`46`	`{`
`47`	`47`	`var token = _disposed.Token;`
`48`		`- while (!token.IsCancellationRequested)`
	`48`	`+ do`
`49`	`49`	`{`
`50`		`- var result = await ComputeResult(_disposed.Token);`
	`50`	`+ var result = await ComputeResult(token);`
`51`	`51`	`if (token.IsCancellationRequested) return;`
`52`	`52`
`53`	`53`	`if (result.ResultOptional.TryGetValue(out var propertyValue))`
`@@ -58,7 +58,7 @@ async void WatchSignalsChanges()`
`58`	`58`	`await using var _ = token.Register(static x => ((SyncCompletionSource)x!).SetCompleted(Unit.Default), result.SignalChangedAwaitable);`
`59`	`59`	`await result.SignalChangedAwaitable;`
`60`	`60`	`_disconnectSubscription.Dispose();`
`61`		`- }`
	`61`	`+ } while (!token.IsCancellationRequested);`
`62`	`62`	`}`
`63`	`63`	`finally`
`64`	`64`	`{`
`@@ -74,8 +74,7 @@ async void WatchSignalsChanges()`
`74`	`74`
`75`	`75`	`async ValueTask<ComputationResult> ComputeResult(CancellationToken cancellationToken)`
`76`	`76`	`{`
`77`		`- var referenceEquality = ReferenceEqualityComparer.Instance;`
`78`		`- HashSet<IReadOnlySignal> signalRequested = new(referenceEquality);`
	`77`	`+ var signalsRequested = new HashSet<IReadOnlySignal>(ReferenceEqualityComparer.Instance);`
`79`	`78`	`Optional<T> result;`
`80`	`79`
`81`	`80`	`_disconnectSubscription = new();`
`@@ -97,7 +96,7 @@ async ValueTask<ComputationResult> ComputeResult(CancellationToken cancellationT`
`97`	`96`	`var signalRequestedSubscription = Signal.SignalsRequested()`
`98`	`97`	`.Subscribe(signal =>`
`99`	`98`	`{`
`100`		`- if (!signalRequested.Add(signal)) return;`
	`99`	`+ if (!signalsRequested.Add(signal)) return;`
`101`	`100`
`102`	`101`	`signal.FutureValues.Subscribe(_ =>`
`103`	`102`	`{`
`@@ -159,8 +158,8 @@ public void Dispose()`
`159`	`158`	`}`
`160`	`159`	`}`
`161`	`160`
`162`		`- record struct ComputationResult(SyncCompletionSource SignalChangedAwaitable, Optional<T> ResultOptional);`
`163`		`- class SyncCompletionSource : INotifyCompletion`
	`161`	`+ readonly record struct ComputationResult(SyncCompletionSource SignalChangedAwaitable, Optional<T> ResultOptional);`
	`162`	`+ sealed class SyncCompletionSource : INotifyCompletion`
`164`	`163`	`{`
`165`	`164`	`Action? _continuation;`
`166`	`165`	`public SyncCompletionSource GetAwaiter() => this;`
`@@ -184,7 +183,7 @@ public void GetResult() {}`
`184`	`183`	`}`
`185`	`184`	`}`
`186`	`185`
`187`		`-internal class ActionStub`
	`186`	`+internal sealed class ActionStub`
`188`	`187`	`{`
`189`	`188`	`public static readonly Action Nop = () => { };`
`190`	`189`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`namespace SignalsDotnet.Internals.ComputedSignalrFactory;`
`6`	`6`
`7`		`-internal class DefaultComputedSignalFactory : IComputedSignalFactory`
	`7`	`+internal sealed class DefaultComputedSignalFactory : IComputedSignalFactory`
`8`	`8`	`{`
`9`	`9`	`public IReadOnlySignal<T> Computed<T>(Func<T> func, Func<Optional<T>> fallbackValue, ReadonlySignalConfigurationDelegate<T?>? configuration = null)`
`10`	`10`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,27 +5,16 @@`
`5`	`5`
`6`	`6`	`namespace SignalsDotnet.Internals.ComputedSignalrFactory;`
`7`	`7`
`8`		`-internal class OnErrorComputedSignalFactoryDecorator : IComputedSignalFactory`
	`8`	`+internal sealed class OnErrorComputedSignalFactoryDecorator(IComputedSignalFactory parent, bool ignoreOperationCancelled, Action<Exception> onException) : IComputedSignalFactory`
`9`	`9`	`{`
`10`		`- readonly IComputedSignalFactory _parent;`
`11`		`- readonly bool _ignoreOperationCancelled;`
`12`		`- readonly Action<Exception> _onException;`
`13`		`-`
`14`		`- public OnErrorComputedSignalFactoryDecorator(IComputedSignalFactory parent, bool ignoreOperationCancelled, Action<Exception> onException)`
`15`		`- {`
`16`		`- _parent = parent;`
`17`		`- _ignoreOperationCancelled = ignoreOperationCancelled;`
`18`		`- _onException = onException;`
`19`		`- }`
`20`		`-`
`21`	`10`	`public IReadOnlySignal<T> Computed<T>(Func<T> func, Func<Optional<T>> fallbackValue, ReadonlySignalConfigurationDelegate<T?>? configuration = null)`
`22`	`11`	`{`
`23`	`12`	`return ComputedObservable(func, fallbackValue).ToSignal(configuration!);`
`24`	`13`	`}`
`25`	`14`
`26`	`15`	`public Observable<T> ComputedObservable<T>(Func<T> func, Func<Optional<T>> fallbackValue)`
`27`	`16`	`{`
`28`		`- return _parent.ComputedObservable(() =>`
	`17`	`+ return parent.ComputedObservable(() =>`
`29`	`18`	`{`
`30`	`19`	`try`
`31`	`20`	`{`
`@@ -47,7 +36,7 @@ public IAsyncReadOnlySignal<T> AsyncComputed<T>(Func<CancellationToken, ValueTas`
`47`	`36`
`48`	`37`	`public Observable<T> AsyncComputedObservable<T>(Func<CancellationToken, ValueTask<T>> func, T startValue, Func<Optional<T>> fallbackValue, ConcurrentChangeStrategy concurrentChangeStrategy = default)`
`49`	`38`	`{`
`50`		`- return _parent.AsyncComputedObservable(async token =>`
	`39`	`+ return parent.AsyncComputedObservable(async token =>`
`51`	`40`	`{`
`52`	`41`	`try`
`53`	`42`	`{`
`@@ -63,7 +52,7 @@ public Observable<T> AsyncComputedObservable<T>(Func<CancellationToken, ValueTas`
`63`	`52`
`64`	`53`	`public ISignal<T> Linked<T>(Func<T> func, Func<Optional<T>> fallbackValue, ReadonlySignalConfigurationDelegate<T?>? configuration = null)`
`65`	`54`	`{`
`66`		`- return _parent.Linked(() =>`
	`55`	`+ return parent.Linked(() =>`
`67`	`56`	`{`
`68`	`57`	`try`
`69`	`58`	`{`
`@@ -83,7 +72,7 @@ public IAsyncSignal<T> AsyncLinked<T>(Func<CancellationToken, ValueTask<T>> func`
`83`	`72`	`ConcurrentChangeStrategy concurrentChangeStrategy = default,`
`84`	`73`	`ReadonlySignalConfigurationDelegate<T>? configuration = null)`
`85`	`74`	`{`
`86`		`- return _parent.AsyncLinked(async token =>`
	`75`	`+ return parent.AsyncLinked(async token =>`
`87`	`76`	`{`
`88`	`77`	`try`
`89`	`78`	`{`
`@@ -99,7 +88,7 @@ public IAsyncSignal<T> AsyncLinked<T>(Func<CancellationToken, ValueTask<T>> func`
`99`	`88`
`100`	`89`	`public Effect Effect(Action onChange, TimeProvider? scheduler = null)`
`101`	`90`	`{`
`102`		`- return _parent.Effect(() =>`
	`91`	`+ return parent.Effect(() =>`
`103`	`92`	`{`
`104`	`93`	`try`
`105`	`94`	`{`
`@@ -115,7 +104,7 @@ public Effect Effect(Action onChange, TimeProvider? scheduler = null)`
`115`	`104`
`116`	`105`	`public Effect AsyncEffect(Func<CancellationToken, ValueTask> onChange, ConcurrentChangeStrategy concurrentChangeStrategy = default, TimeProvider? scheduler = null)`
`117`	`106`	`{`
`118`		`- return _parent.AsyncEffect(async token =>`
	`107`	`+ return parent.AsyncEffect(async token =>`
`119`	`108`	`{`
`120`	`109`	`try`
`121`	`110`	`{`
`@@ -131,11 +120,14 @@ public Effect AsyncEffect(Func<CancellationToken, ValueTask> onChange, Concurren`
`131`	`120`
`132`	`121`	`void NotifyException(Exception e)`
`133`	`122`	`{`
`134`		`- if (_ignoreOperationCancelled && e is OperationCanceledException)`
	`123`	`+ if (ignoreOperationCancelled && e is OperationCanceledException)`
`135`	`124`	`{`
`136`	`125`	`return;`
`137`	`126`	`}`
`138`	`127`
`139`		`- Signal.Untracked(() => _onException(e));`
	`128`	`+ using (Signal.UntrackedScope())`
	`129`	`+ {`
	`130`	`+ onException(e);`
	`131`	`+ }`
`140`	`132`	`}`
`141`	`133`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,22 +1,17 @@`
`1`	`1`	`namespace SignalsDotnet.Internals.Helpers;`
`2`	`2`
`3`		`-internal class KeyEqualityComparer<T, TDestination> : IEqualityComparer<T> where TDestination : notnull`
	`3`	`+internal sealed class KeyEqualityComparer<T, TDestination>(Func<T?, TDestination> keyExtractor) : IEqualityComparer<T>`
	`4`	`+ where TDestination : notnull`
`4`	`5`	`{`
`5`		`- readonly Func<T?, TDestination> _keyExtractor;`
`6`	`6`	`readonly EqualityComparer<TDestination> _equalityComparer = EqualityComparer<TDestination>.Default;`
`7`	`7`
`8`		`- public KeyEqualityComparer(Func<T?, TDestination> keyExtractor)`
`9`		`- {`
`10`		`- _keyExtractor = keyExtractor;`
`11`		`- }`
`12`		`-`
`13`	`8`	`public bool Equals(T? x, T? y)`
`14`	`9`	`{`
`15`		`- return _equalityComparer.Equals(_keyExtractor(x), _keyExtractor(y));`
	`10`	`+ return _equalityComparer.Equals(keyExtractor(x), keyExtractor(y));`
`16`	`11`	`}`
`17`	`12`
`18`	`13`	`public int GetHashCode(T? obj)`
`19`	`14`	`{`
`20`		`- return _equalityComparer.GetHashCode(_keyExtractor(obj));`
	`15`	`+ return _equalityComparer.GetHashCode(keyExtractor(obj));`
`21`	`16`	`}`
`22`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,14 +10,9 @@ internal static class ObservableFromINotifyCollectionChanged`
`10`	`10`	`return new CollectionChangedObservable(collection);`
`11`	`11`	`}`
`12`	`12`
`13`		`- class CollectionChangedObservable : Observable<(object? sender, NotifyCollectionChangedEventArgs e)>`
	`13`	`+ sealed class CollectionChangedObservable(INotifyCollectionChanged notifyCollectionChanged) : Observable<(object? sender, NotifyCollectionChangedEventArgs e)>`
`14`	`14`	`{`
`15`		`- readonly INotifyCollectionChanged _notifyCollectionChanged;`
`16`		`-`
`17`		`- public CollectionChangedObservable(INotifyCollectionChanged notifyCollectionChanged)`
`18`		`- {`
`19`		`- _notifyCollectionChanged = notifyCollectionChanged;`
`20`		`- }`
	`15`	`+ readonly INotifyCollectionChanged _notifyCollectionChanged = notifyCollectionChanged;`
`21`	`16`
`22`	`17`	`protected override IDisposable SubscribeCore(Observer<(object? sender, NotifyCollectionChangedEventArgs e)> observer)`
`23`	`18`	`{`