public void BasicTest() { var ts = TaskSource.New <int>(TaskCreationOptions.None); ts.Task.IsCompleted.Should().BeFalse(); ts.SetResult(1); ts.TrySetResult(2).Should().BeFalse(); ts.Task.IsCompletedSuccessfully().Should().BeTrue(); ts.Task.Result.Should().Be(1); ts = TaskSource.New <int>(TaskCreationOptions.None); ts.Task.IsCompleted.Should().BeFalse(); var e = new InvalidOperationException(); ts.SetException(e); ts.TrySetException(new InvalidOperationException()).Should().BeFalse(); ts.Task.IsCompleted.Should().BeTrue(); ts.Task.IsFaulted.Should().BeTrue(); ts.Task.Exception.Should().NotBeNull(); ts = TaskSource.New <int>(TaskCreationOptions.None); ts.Task.IsCompleted.Should().BeFalse(); using var cts = new CancellationTokenSource(); ts.SetCanceled(); ts.TrySetCanceled(cts.Token).Should().BeFalse(); ts.Task.IsCompleted.Should().BeTrue(); ts.Task.IsFaulted.Should().BeFalse(); ts.Task.IsCanceled.Should().BeTrue(); }
private void Reset() { _nextMessageTask = TaskSource.New <RedisValue>(true).Task; if (IsDisposeStarted) { TaskSource.For(_nextMessageTask).TrySetCanceled(); } }
public static Task InvalidatedAsync <T>(this IComputed <T> computed, CancellationToken cancellationToken = default) { if (computed.State == ComputedState.Invalidated) { return(Task.CompletedTask); } var ts = TaskSource.New <Unit>(true); computed.Invalidated += c => ts.SetResult(default);
public StateSnapshot(IState <T> state, IComputed <T> computed) { State = state; Computed = computed; LatestNonErrorComputed = computed; WhenUpdatingSource = TaskSource.New <Unit>(true); WhenUpdatedSource = TaskSource.New <Unit>(true); UpdateCount = 0; ErrorCount = 0; RetryCount = 0; }
protected async ValueTask <Releaser> FastInternalLockAsync( ReentryCounter?reentryCounter, CancellationToken cancellationToken = default) { var newLockSrc = TaskSource.New <Unit>(_taskCreationOptions); var cancellationTask = (Task?)null; while (true) { cancellationToken.ThrowIfCancellationRequested(); if (reentryCounter?.TryReenter(ReentryMode) == true) { return(new Releaser(this, default, reentryCounter));
protected static void EndDelay(ref Task <Unit> task, TimeSpan withDelay = default) { var newTask = TaskSource.New <Unit>(true).Task; var oldTask = Interlocked.Exchange(ref task, newTask); if (oldTask == null) { return; } if (withDelay == default) { TaskSource.For(oldTask).SetResult(default);
// ToTask (typed) public static Disposable <Task <T>, CancellationTokenRegistration> ToTask <T>( this CancellationToken token, TaskCreationOptions taskCreationOptions = default) { var ts = TaskSource.New <T>(taskCreationOptions); var r = token.Register(() => ts.SetCanceled(token)); #if NETSTANDARD return(Disposable.New(ts.Task, r, (_, r1) => r1.Dispose())); #else return(Disposable.New(ts.Task, r, (_, r1) => r1.Unregister())); #endif }
protected async ValueTask <Releaser> FastInternalLock( ReentryCounter?reentryCounter, CancellationToken cancellationToken = default) { var newLockSrc = TaskSource.New <Unit>(_taskCreationOptions); var dCancellationTokenTask = new Disposable <Task, CancellationTokenRegistration>(); try { for (;;) { cancellationToken.ThrowIfCancellationRequested(); if (reentryCounter?.TryReenter(ReentryMode) == true) { return(new Releaser(this, default, reentryCounter));
public void CancelDelays(bool immediately = false) { if (!immediately) { Clock .DelayAsync(CancelDelaysDelay, CancellationToken.None) .ContinueWith(_ => CancelDelays(true)); return; } var newTask = TaskSource.New <Unit>(true).Task; var oldTask = Interlocked.Exchange(ref _cancelDelaysTask, newTask); if (oldTask != null) { TaskSource.For(oldTask).SetResult(default);
public void CancelDelays(TimeSpan?cancellationDelay = null) { var delay = Math.Max(0, (cancellationDelay ?? CancellationDelay).TotalSeconds); if (delay > 0) { Clock.DelayAsync(TimeSpan.FromSeconds(delay)).ContinueWith(_ => CancelDelays(TimeSpan.Zero)); return; } var newTask = TaskSource.New <Unit>(true).Task; var oldTask = Interlocked.Exchange(ref _cancelDelaysTask, newTask); if (oldTask != null) { TaskSource.For(oldTask).SetResult(default);
public async Task BasicTest() { if (TestRunnerInfo.IsBuildAgent()) { return; // No Redis on build agent for now } var db = GetRedisDb(); var started = TaskSource.New <Unit>(true); var streamer = db.GetStreamer <int>("s"); await streamer.Remove(); var streamerCopy = db.GetStreamer <int>("s"); var writeTask = streamer.Write( Delays(new[] { 0.1, 0.2, 0.3, 0.1 }), _ => started.SetResult(default));
public static Disposable <Task, CancellationTokenRegistration> ToTask( this CancellationToken token, Exception exceptionWhenCancelled, TaskCreationOptions taskCreationOptions = default) { // ReSharper disable once HeapView.PossibleBoxingAllocation var ts = TaskSource.New <Unit>(exceptionWhenCancelled, taskCreationOptions); var r = token.Register(arg => { var ts1 = TaskSource.For((Task <Unit>)arg !); ts1.SetException((Exception)ts1.Task.AsyncState !); }, ts.Task); #if NETSTANDARD return(Disposable.New((Task)ts.Task, r, (_, r1) => r1.Dispose())); #else return(Disposable.New((Task)ts.Task, r, (_, r1) => r1.Unregister())); #endif }
protected virtual async Task Run(TimeSpan duration, CancellationToken cancellationToken) { Counters.Clear(); var startTaskSource = TaskSource.New <Unit>(true); var tasks = Enumerable.Range(0, ConcurrencyLevel) .Select(async i => { await startTaskSource.Task.ConfigureAwait(false); return(await Benchmark(i, duration, cancellationToken).ConfigureAwait(false)); }) .ToArray(); await Task.Delay(100, cancellationToken).ConfigureAwait(false); // Wait to make sure all the tasks are created & scheduled if (ForceGCCollect) { GC.Collect(); } Stopwatch = Stopwatch.StartNew(); startTaskSource.SetResult(default);
public PublicationState(IPublication <T> publication, IComputed <T> computed, Moment createdAt, bool isDisposed, TaskSource <Unit> whenInvalidatedSource = default, TaskSource <Unit> whenOutdatedSource = default) { if (whenInvalidatedSource.IsEmpty) { whenInvalidatedSource = TaskSource.New <Unit>(true); } if (whenOutdatedSource.IsEmpty) { whenOutdatedSource = TaskSource.New <Unit>(true); } Publication = publication; CreatedAt = createdAt; IsDisposed = isDisposed; WhenInvalidatedSource = whenInvalidatedSource; WhenOutdatedSource = whenOutdatedSource; Computed = computed; computed.Invalidated += _ => WhenInvalidatedSource.TrySetResult(default);
protected override ILiveState <T> CreateState() => StateFactory.NewLive <T>(ConfigureState, async(_, ct) => { // Default CreateState synchronizes ComputeStateAsync call // as per https://github.com/servicetitan/Stl.Fusion/issues/202 // You can override it to implement a version w/o sync. var ts = TaskSource.New <T>(false); await InvokeAsync(async() => { try { ts.TrySetResult(await ComputeStateAsync(ct)); } catch (OperationCanceledException) { ts.TrySetCanceled(); } catch (Exception e) { ts.TrySetException(e); } }); return(await ts.Task.ConfigureAwait(false)); }, this);
public static async Task <FileSystemEventArgs> FirstAsync( this FileSystemWatcher watcher, TaskCreationOptions taskCreationOptions, CancellationToken cancellationToken = default) { var ts = TaskSource.New <FileSystemEventArgs>(taskCreationOptions); var handler = (FileSystemEventHandler)((sender, args) => ts.TrySetResult(args)); try { watcher.Changed += handler; watcher.Created += handler; watcher.Deleted += handler; return(await ts.Task.WithFakeCancellation(cancellationToken).ConfigureAwait(false)); } finally { watcher.Changed -= handler; watcher.Created -= handler; watcher.Deleted -= handler; } }
public StateSnapshot(StateSnapshot <T> prevSnapshot, IComputed <T> computed) { State = prevSnapshot.State; Computed = computed; WhenUpdatingSource = TaskSource.New <Unit>(true); WhenUpdatedSource = TaskSource.New <Unit>(true); if (computed.HasValue) { LatestNonErrorComputed = computed; UpdateCount = 1 + prevSnapshot.UpdateCount; ErrorCount = prevSnapshot.ErrorCount; RetryCount = 0; } else { LatestNonErrorComputed = prevSnapshot.LatestNonErrorComputed; UpdateCount = 1 + prevSnapshot.UpdateCount; ErrorCount = 1 + prevSnapshot.ErrorCount; RetryCount = 1 + prevSnapshot.RetryCount; } }
protected override ILiveState <T> CreateState() => 0 != (Options & LiveComponentOptions.SynchronizeComputeState) ? StateFactory.NewLive <T>(ConfigureState, async(_, ct) => { // Synchronizes ComputeStateAsync call as per: // https://github.com/servicetitan/Stl.Fusion/issues/202 var ts = TaskSource.New <T>(false); await InvokeAsync(async() => { try { ts.TrySetResult(await ComputeStateAsync(ct)); } catch (OperationCanceledException) { ts.TrySetCanceled(); } catch (Exception e) { ts.TrySetException(e); } }); return(await ts.Task.ConfigureAwait(false)); }, this) : StateFactory.NewLive <T>(ConfigureState, (_, ct) => ComputeStateAsync(ct), this);