Signal lib

src/Library/Signal.Tests/DisposeTests.cs

@@ -0,0 +1,64 @@
+using Xunit;
+
+namespace Signal.Tests;
+
+public class DisposeTests
+{
+    [Fact]
+    public void Disposed_AfterDispose_ShouldBeTrue()
+    {
+        // Arrange
+        var signal = new Signal<int>(0);
+        
+        // Act
+        signal.Dispose();
+        
+        // Assert
+        Assert.True(signal.IsDisposed);
+    }
+    
+    [Fact]
+    public void Disposed_AfterDispose_ShouldInvokeDisposedEvent()
+    {
+        // Arrange
+        var signal = new Signal<int>(0);
+        var disposedInvoked = false;
+        signal.Disposed += _ => disposedInvoked = true;
+        
+        // Act
+        signal.Dispose();
+        
+        // Assert
+        Assert.True(disposedInvoked);
+    }
+    
+    [Fact]
+    public void ChildSignalDisposed_AfterParentSignalDispose_ShouldBeTrue()
+    {
+        // Arrange
+        var parentSignal = new Signal<int>(0);
+        var childSignal = parentSignal.Map(v => v);
+        
+        // Act
+        parentSignal.Dispose();
+        
+        // Assert
+        Assert.True(childSignal.IsDisposed);
+    }
+    
+    [Fact]
+    public void ChildSignalDisposed_AfterParentSignalDispose_ShouldInvokeDisposedEvent()
+    {
+        // Arrange
+        var parentSignal = new Signal<int>(0);
+        var childSignal = parentSignal.Map(v => v);
+        var disposedInvoked = false;
+        childSignal.Disposed += _ => disposedInvoked = true;
+        
+        // Act
+        parentSignal.Dispose();
+        
+        // Assert
+        Assert.True(disposedInvoked);
+    }
+}

src/Library/Signal.Tests/LockingTests.cs

@@ -0,0 +1,50 @@
+using Xunit;
+
+namespace Signal.Tests;
+
+public class LockingTests
+{
+    // These tests are not working, but you get the idea, figure them out sometimes in the future, gl&hf
+    
+    [Fact]
+    public async Task SetAndGet_WhenGetRunsFirst_ShouldNotDeadlock()
+    {
+        // Arrange
+        var signal = new Signal<int>(0);
+        var childSignal = signal.Map(async v =>
+        {
+            await Task.Delay(200);
+            return v;
+        });
+        
+        // Act
+        await Task.WhenAll(
+            Task.Run(async () => await signal.GetValueAsync()),
+            Task.Run(() => signal.SetValue(1))
+        );
+        
+        // Assert
+        // If this does not deadlock we are okay
+    }
+    
+    [Fact]
+    public async Task SetAndGet_WhenSetRunsFirst_ShouldNotDeadlock()
+    {
+        // Arrange
+        var signal = new Signal<int>(0);
+        var childSignal = signal.Map(async v =>
+        {
+            await Task.Delay(200);
+            return v;
+        });
+        
+        // Act
+        await Task.WhenAll(
+            Task.Run(() => signal.SetValue(1)),
+            Task.Run(async () => await signal.GetValueAsync())
+        );
+        
+        // Assert
+        // If this does not deadlock we are okay
+    }
+}

src/Library/Signal.Tests/Signal.Tests.csproj

@@ -1,14 +1,26 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <OutputType>Exe</OutputType>
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="xunit.v3" Version="0.1.1-pre.396" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
+    <PackageReference Include="xunit" Version="2.7.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.8">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="6.0.2">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 
   <ItemGroup>

src/Library/Signal.Tests/SyncLikeBehaviourTests.cs

@@ -0,0 +1,44 @@
+using Xunit;
+
+namespace Signal.Tests;
+
+public class SyncLikeBehaviourTests
+{
+    [Fact(Timeout = 500)]
+    public async Task Signal_WhenAwaitedInstantly_ShouldBehaveLikeSync()
+    {
+        // Arrange
+        var signal = new Signal<int>(1);
+        
+        // Act
+        var val1 = await signal.GetValueAsync();
+        signal.SetValue(2);
+        var val2 = await signal.GetValueAsync();
+        signal.SetValue(3);
+        var val3 = await signal.GetValueAsync();
+        
+        // Assert
+        Assert.Equal(1, val1);
+        Assert.Equal(2, val2);
+        Assert.Equal(3, val3);
+    }
+    
+    [Fact(Timeout = 500)]
+    public async Task Signal_WhenNotAwaitedInstantly_ShouldBehaveLikeSync()
+    {
+        // Arrange
+        var signal = new Signal<int>(1);
+        
+        // Act
+        var val1 = signal.GetValueAsync();
+        signal.SetValue(2);
+        var val2 = signal.GetValueAsync();
+        signal.SetValue(3);
+        var val3 = signal.GetValueAsync();
+        
+        // Assert
+        Assert.Equal(1, await val1);
+        Assert.Equal(2, await val2);
+        Assert.Equal(3, await val3);
+    }
+}

src/Library/Signal.Tests/xunit.runner.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://xunit.net/schema/current/xunit.runner.schema.json",
+  "longRunningTestSeconds": 5
+}

src/Library/Signal/CombineLatestSignal.cs

@@ -1,34 +1,43 @@
 namespace Signal;
 
-public class CombineLatestSignal<T1, T2, TResult> : SignalBase<TResult>
+public sealed class CombineLatestSignal<T1, T2, TResult> : SignalBase<TResult>
 {
     private readonly Func<ValueTask<TResult>> _combine;
     private TResult _result;
     
-    public CombineLatestSignal(IReadOnlySignal<T1> signal1, IReadOnlySignal<T2> signal2, Func<T1, T2, TResult> combine) 
+    public CombineLatestSignal(SignalBase<T1> signal1, SignalBase<T2> signal2, Func<T1, T2, TResult> combine) 
-        : base(new IReadOnlySignal[] { signal1, signal2 })
+        : base(new SignalBase[] { signal1, signal2 })
     {
         _combine = CombineAsync;
         
-        async ValueTask<TResult> CombineAsync() => combine(await signal1.GetValueAsync(), await signal2.GetValueAsync());
+        async ValueTask<TResult> CombineAsync()
-        
+        {
+            var val1 = await signal1.GetValueAsync();
+            var val2 = await signal2.GetValueAsync();
+            return combine(val1, val2);
+        }
     }
     
-    public CombineLatestSignal(IReadOnlySignal<T1> signal1, IReadOnlySignal<T2> signal2, Func<T1, T2, Task<TResult>> combine) 
+    public CombineLatestSignal(SignalBase<T1> signal1, SignalBase<T2> signal2, Func<T1, T2, Task<TResult>> combine) 
-        : base(new IReadOnlySignal[] { signal1, signal2 })
+        : base(new SignalBase[] { signal1, signal2 })
     {
         _combine = CombineAsync;
         
-        async ValueTask<TResult> CombineAsync() => await combine(await signal1.GetValueAsync(), await signal2.GetValueAsync());
+        async ValueTask<TResult> CombineAsync()
+        {
+            var val1 = await signal1.GetValueAsync();
+            var val2 = await signal2.GetValueAsync();
+            return await combine(val1, val2);
+        }
     }
 
-    public override async ValueTask<TResult> GetValueAsync()
+    protected override async ValueTask<TResult> GetValueInternalAsync()
     {
-        //TODO synchronization
         if (!IsDirty)
         {
             return _result;
         }
+        
         IsDirty = false;
         _result = await _combine();
         return _result;

src/Library/Signal/Extensions.cs

@@ -2,11 +2,11 @@ namespace Signal;
 
 public static class Extensions
 {
-    public static IReadOnlySignal<TResult> Map<T, TResult>(this IReadOnlySignal<T> signal, Func<T, TResult> map)
+    public static SignalBase<TResult> Map<T, TResult>(this SignalBase<T> signal, Func<T, TResult> map)
     {
         return new MapSignal<T, TResult>(signal, map);
     }
-    public static IReadOnlySignal<TResult> Map<T, TResult>(this IReadOnlySignal<T> signal, Func<T, Task<TResult>> map)
+    public static SignalBase<TResult> Map<T, TResult>(this SignalBase<T> signal, Func<T, Task<TResult>> map)
     {
         return new MapSignal<T, TResult>(signal, map);
     }

src/Library/Signal/Helpers.cs

@@ -2,13 +2,13 @@ namespace Signal;
 
 public static class Helpers
 {
-    public static IReadOnlySignal<TResult> CombineLatest<T1, T2, TResult>(IReadOnlySignal<T1> signal1,
+    public static SignalBase<TResult> CombineLatest<T1, T2, TResult>(SignalBase<T1> signal1,
-        IReadOnlySignal<T2> signal2, Func<T1, T2, TResult> combine)
+        SignalBase<T2> signal2, Func<T1, T2, TResult> combine)
     {
         return new CombineLatestSignal<T1, T2, TResult>(signal1, signal2, combine);
     }
-    public static IReadOnlySignal<TResult> CombineLatest<T1, T2, TResult>(IReadOnlySignal<T1> signal1,
+    public static SignalBase<TResult> CombineLatest<T1, T2, TResult>(SignalBase<T1> signal1,
-        IReadOnlySignal<T2> signal2, Func<T1, T2, Task<TResult>> combine)
+        SignalBase<T2> signal2, Func<T1, T2, Task<TResult>> combine)
     {
         return new CombineLatestSignal<T1, T2, TResult>(signal1, signal2, combine);
     }

src/Library/Signal/IReadOnlySignal.cs

@@ -1,10 +1,9 @@
 namespace Signal;
 
-public interface IReadOnlySignal
+public interface IReadOnlySignal : IDisposable
 {
     bool IsDirty { get; }
     event Action<bool> IsDirtyChanged;
-    internal void SetDirty();
 }
 public interface IReadOnlySignal<T> : IReadOnlySignal
 {

src/Library/Signal/ISignal.cs

@@ -3,4 +3,5 @@ namespace Signal;
 public interface ISignal<T> : IReadOnlySignal<T>
 {
     void SetValue(T value);
+    Task SetValueAsync(T value);
 }

src/Library/Signal/MapSignal.cs

@@ -1,31 +1,56 @@
 namespace Signal;
 
-public class MapSignal<T, TResult> : SignalBase<TResult>
+public sealed class MapSignal<T, TResult> : SignalBase<TResult>
 {
-    private readonly Func<ValueTask<TResult>> _map;
+    private readonly Func<T, ValueTask<TResult>> _map;
-    private TResult _result;
+    private readonly SignalBase<T> _parentSignal;
-    public MapSignal(IReadOnlySignal<T> signal, Func<T, TResult> map) : base(signal)
+    private T? _lastParentValue;
+    private TResult? _lastResult;
+
+    private MapSignal(SignalBase<T> signal) : base(signal)
+    {
+        _parentSignal = signal;
+    }
+
+    public MapSignal(SignalBase<T> signal, Func<T, TResult> map) : this(signal)
     {
         _map = MapValueAsync;
 
-        async ValueTask<TResult> MapValueAsync() => map(await signal.GetValueAsync());
+        ValueTask<TResult> MapValueAsync(T val) => new(map(val));
     }
-    public MapSignal(IReadOnlySignal<T> signal, Func<T, Task<TResult>> map) : base(signal)
+
+    public MapSignal(SignalBase<T> signal, Func<T, Task<TResult>> map) : this(signal)
     {
         _map = MapValueAsync;
 
-        async ValueTask<TResult> MapValueAsync() => await map(await signal.GetValueAsync());
+        async ValueTask<TResult> MapValueAsync(T val) => await map(val);
     }
 
-    public override async ValueTask<TResult> GetValueAsync()
+    public MapSignal(SignalBase<T> signal, Func<T, ValueTask<TResult>> map) : this(signal)
+    {
+        _map = MapValueAsync;
+
+        async ValueTask<TResult> MapValueAsync(T val) => await map(val);
+    }
+
+    protected override async ValueTask<TResult> GetValueInternalAsync()
     {
-        //TODO synchronization
         if (!IsDirty)
         {
-            return _result;
+            return _lastResult!;
         }
+
         IsDirty = false;
-        _result = await _map();
+        var baseValue = await _parentSignal.GetValueAsync();
-        return _result;
+        if (
+            (_lastParentValue == null && baseValue == null) ||
+            (baseValue != null && baseValue.Equals(_lastParentValue)))
+        {
+            return _lastResult!;
+        }
+
+        _lastParentValue = baseValue;
+        _lastResult = await _map(baseValue);
+        return _lastResult;
     }
 }

src/Library/Signal/Signal.cs

@@ -1,6 +1,6 @@
 namespace Signal;
 
-public class Signal<T> : SignalBase<T>, ISignal<T>
+public sealed class Signal<T> : SignalBase<T>, ISignal<T>
 {
     private T _value;
 
@@ -11,11 +11,33 @@ public class Signal<T> : SignalBase<T>, ISignal<T>
 
     public void SetValue(T value)
     {
-        _value = value;
+        TreeLock.Lock();
-        SetDirty();
+        try
+        {
+            _value = value;
+            IsDirty = true;
+        }
+        finally
+        {
+            TreeLock.Release();
+        }
     }
 
-    public override ValueTask<T> GetValueAsync()
+    public async Task SetValueAsync(T value)
+    {
+        await TreeLock.LockAsync();
+        try
+        {
+            _value = value;
+            IsDirty = true;
+        }
+        finally
+        {
+            TreeLock.Release();
+        }
+    }
+
+    protected override ValueTask<T> GetValueInternalAsync()
     {
         IsDirty = false;
         return new ValueTask<T>(_value);

src/Library/Signal/SignalBase.cs

@@ -1,50 +1,122 @@
 namespace Signal;
 
-public abstract class SignalBase<T> : IReadOnlySignal<T>
+public abstract class SignalBase : IReadOnlySignal
 {
-    private readonly List<SignalBase<T>> _dependentSignals = [];
+    private bool _isDirty = true;
-    public bool IsDirty { get; protected set; } = true;
+
     public event Action<bool>? IsDirtyChanged;
 
-    public SignalBase()
+    public bool IsDirty
     {
-        
+        get => _isDirty;
-    }
+        protected set
-
-    public SignalBase(IReadOnlySignal baseSignal)
-    {
-        HandleDependentSignal(baseSignal);
-    }
-
-    public SignalBase(IEnumerable<IReadOnlySignal> baseSignal)
-    {
-        foreach (var signal in baseSignal)
         {
-            HandleDependentSignal(signal);
+            if (_isDirty == value)
-        }
-    }
-    
-    private void HandleDependentSignal(IReadOnlySignal baseSignal)
-    {
-        baseSignal.IsDirtyChanged += isDirty =>
-        {
-            if (isDirty)
             {
-                SetDirty();
+                return;
             }
-        };
+
+            _isDirty = value;
+            IsDirtyChanged?.Invoke(value);
+        }
+    }
+    public event Action<SignalBase> Disposed;
+    public bool IsDisposed { get; private set; }
+    
+    internal TreeLocker TreeLock { get; }
+    
+    private protected SignalBase(TreeLocker treeTreeLock)
+    {
+        TreeLock = treeTreeLock;
     }
 
-    public void SetDirty()
+    public virtual void Dispose()
     {
-        IsDirty = true;
+        // TODO: disposing pattern
-        for (var i = 0; i < _dependentSignals.Count; i++)
+        IsDisposed = true;
+        Disposed?.Invoke(this);
+    }
+}
+
+public abstract class SignalBase<T> : SignalBase, IReadOnlySignal<T>
+{
+    internal static AsyncLocal<TreeLocker> CurrentTreeLocker { get; } = new();
+    private protected SignalBase():base(new TreeLocker())
+    {
+    }
+
+    protected SignalBase(SignalBase parentSignal):base(parentSignal.TreeLock)
+    {
+        SubscribeToParentSignalChanges(parentSignal);
+    }
+
+    protected SignalBase(ICollection<SignalBase> parentSignals):base(CreateMultiParentTreeLock(parentSignals))
+    {
+        ArgumentOutOfRangeException.ThrowIfZero(parentSignals.Count);
+        
+        foreach (var parentSignal in parentSignals)
         {
-            _dependentSignals[i].SetDirty();
+            SubscribeToParentSignalChanges(parentSignal);
+        }
+    }
+
+    private static TreeLocker CreateMultiParentTreeLock(ICollection<SignalBase> parentSignals)
+    {
+        var firstLock = parentSignals.First().TreeLock;
+        foreach (var parentSignal in parentSignals.Skip(1))
+        {
+            parentSignal.TreeLock.UseInstead(firstLock);
         }
         
-        IsDirtyChanged?.Invoke(IsDirty);
+        return firstLock;
     }
 
-    public abstract ValueTask<T> GetValueAsync();
+    private void SubscribeToParentSignalChanges(SignalBase parentSignal)
+    {
+        // Note: Do not forget to unsubscribe from the parent signal when this signal is disposed.
+        parentSignal.IsDirtyChanged += HandleParentIsDirtyChanged;
+        parentSignal.Disposed += UnsubscribeFromParentSignalChangesAndDispose;
+    }
+
+    private void HandleParentIsDirtyChanged(bool isDirty)
+    {
+        if (isDirty)
+        {
+            IsDirty = true;
+        }
+    }
+
+    private void UnsubscribeFromParentSignalChangesAndDispose(SignalBase parentSignal)
+    {
+        parentSignal.IsDirtyChanged -= HandleParentIsDirtyChanged;
+        parentSignal.Disposed -= UnsubscribeFromParentSignalChangesAndDispose;
+
+        Dispose();
+    }
+
+    protected abstract ValueTask<T> GetValueInternalAsync();
+
+    public async ValueTask<T> GetValueAsync()
+    {
+        var shouldReleaseLock = false;
+        if (CurrentTreeLocker.Value != TreeLock)
+        {
+            await TreeLock.LockAsync();
+            shouldReleaseLock = true;
+            CurrentTreeLocker.Value = TreeLock;
+        }
+
+        try
+        {
+            return await GetValueInternalAsync();
+        }
+        finally
+        {
+            if (shouldReleaseLock)
+            {
+                CurrentTreeLocker.Value = null;
+                TreeLock.Release();
+            }
+        }
+    }
 }

src/Library/Signal/TreeLocker.cs

@@ -0,0 +1,71 @@
+namespace Signal;
+
+internal sealed class TreeLocker
+{
+    private bool Equals(TreeLocker other) => _mainSemaphore.Equals(other._mainSemaphore);
+
+    public override bool Equals(object? obj) => ReferenceEquals(this, obj) || obj is TreeLocker other && Equals(other);
+
+    public override int GetHashCode() => _mainSemaphore.GetHashCode();
+
+    public static bool operator ==(TreeLocker? left, TreeLocker? right) => Equals(left, right);
+    public static bool operator !=(TreeLocker? left, TreeLocker? right) => !Equals(left, right);
+
+    private SemaphoreSlim _lastLockedMainSemaphore;
+    private SemaphoreSlim _mainSemaphore = new(1, 1);
+    private readonly SemaphoreSlim _semaphoreSemaphore = new(1, 1);
+
+    public void Lock()
+    {
+        _semaphoreSemaphore.Wait();
+        try
+        {
+            _lastLockedMainSemaphore = _mainSemaphore;
+            _lastLockedMainSemaphore.Wait();
+        }
+        finally
+        {
+            _semaphoreSemaphore.Release();
+        }
+    }
+
+    public Task LockAsync()
+    {
+        _semaphoreSemaphore.Wait();
+        try
+        {
+            _lastLockedMainSemaphore = _mainSemaphore;
+            return _lastLockedMainSemaphore.WaitAsync();
+        }
+        finally
+        {
+            _semaphoreSemaphore.Release();
+        }
+    }
+
+    public void Release()
+    {
+        try
+        {
+            _semaphoreSemaphore.Wait();
+            _lastLockedMainSemaphore.Release();
+        }
+        finally
+        {
+            _semaphoreSemaphore.Release();
+        }
+    }
+
+    internal void UseInstead(TreeLocker newBaseLocker)
+    {
+        try
+        {
+            _semaphoreSemaphore.Wait();
+            _mainSemaphore = newBaseLocker._mainSemaphore;
+        }
+        finally
+        {
+            _semaphoreSemaphore.Release();
+        }
+    }
+}