ADIX7/FileTime2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Signal lib

Browse Source
This commit is contained in:
Ádám Kovács
2024-04-29 11:47:39 +02:00
parent d523dd6880
commit 51a81ddf53
14 changed files with 450 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
src/Library/Signal.Tests/DisposeTests.cs Normal file
View File

@@ -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);
}
}

50
src/Library/Signal.Tests/LockingTests.cs Normal file
View File

@@ -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
}
}

16
src/Library/Signal.Tests/Signal.Tests.csproj
View File

@@ -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>

44
src/Library/Signal.Tests/SyncLikeBehaviourTests.cs Normal file
View File

@@ -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);
}
}

4
src/Library/Signal.Tests/xunit.runner.json Normal file
View File

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

29
src/Library/Signal/CombineLatestSignal.cs
View File

@@ -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)
: base(new IReadOnlySignal[] { signal1, signal2 })
public CombineLatestSignal(SignalBase<T1> signal1, SignalBase<T2> signal2, Func<T1, T2, TResult> combine)
: 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)
: base(new IReadOnlySignal[] { signal1, signal2 })
public CombineLatestSignal(SignalBase<T1> signal1, SignalBase<T2> signal2, Func<T1, T2, Task<TResult>> combine)
: 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;

4
src/Library/Signal/Extensions.cs
View File

@@ -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);
}

8
src/Library/Signal/Helpers.cs
View File

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

3
src/Library/Signal/IReadOnlySignal.cs
View File

@@ -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
{

1
src/Library/Signal/ISignal.cs
View File

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

49
src/Library/Signal/MapSignal.cs
View File

@@ -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 TResult _result;
public MapSignal(IReadOnlySignal<T> signal, Func<T, TResult> map) : base(signal)
private readonly Func<T, ValueTask<TResult>> _map;
private readonly SignalBase<T> _parentSignal;
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();
return _result;
var baseValue = await _parentSignal.GetValueAsync();
if (
(_lastParentValue == null && baseValue == null) ||
(baseValue != null && baseValue.Equals(_lastParentValue)))
{
return _lastResult!;
}
_lastParentValue = baseValue;
_lastResult = await _map(baseValue);
return _lastResult;
}
}

30
src/Library/Signal/Signal.cs
View File

@@ -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;
SetDirty();
TreeLock.Lock();
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);

136
src/Library/Signal/SignalBase.cs
View File

@@ -1,50 +1,122 @@
namespace Signal;
public abstract class SignalBase<T> : IReadOnlySignal<T>
public abstract class SignalBase : IReadOnlySignal
{
private readonly List<SignalBase<T>> _dependentSignals = [];
public bool IsDirty { get; protected set; } = true;
private bool _isDirty = true;
public event Action<bool>? IsDirtyChanged;
public SignalBase()
public bool IsDirty
{
}
public SignalBase(IReadOnlySignal baseSignal)
{
HandleDependentSignal(baseSignal);
}
public SignalBase(IEnumerable<IReadOnlySignal> baseSignal)
{
foreach (var signal in baseSignal)
get => _isDirty;
protected set
{
HandleDependentSignal(signal);
}
}
private void HandleDependentSignal(IReadOnlySignal baseSignal)
{
baseSignal.IsDirtyChanged += isDirty =>
{
if (isDirty)
if (_isDirty == value)
{
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;
for (var i = 0; i < _dependentSignals.Count; i++)
// TODO: disposing pattern
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();
}
}
}
}

71
src/Library/Signal/TreeLocker.cs Normal file
View File

@@ -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();
}
}
}