DotNext.Threading by Roman Sakno

<PackageReference Include="DotNext.Threading" Version="2.6.1" />

---

API Diff between 2.6.1 and 0.5.0

178 Additions 40 Removals

DotNext.Runtime.CompilerServices

• public sealed class CancellationTokenFuture : Future<Task>, IAwaiter, IFuture, INotifyCompletion
  • public IAwaiter GetAwaiter()
• public sealed class WaitHandleFuture : Future<Task<bool>>, IAwaiter<bool>, IFuture, INotifyCompletion
  • public IAwaiter<bool> GetAwaiter()

DotNext.Threading

• public class AsyncAutoResetEvent : QueuedSynchronizer, IAsyncResetEvent, IAsyncEvent, ISynchronizer, IDisposable
  • public bool IsSet { get; }
  • public AsyncAutoResetEvent(bool initialState)
  • public bool Reset()
  • public bool Set()
  • public Task<bool> WaitAsync(TimeSpan timeout, CancellationToken token)
• public class AsyncBarrier : Disposable, IAsyncEvent, ISynchronizer, IDisposable
  • public long CurrentPhaseNumber { get; }
  • public long ParticipantCount { get; }
  • public long ParticipantsRemaining { get; }
  • public AsyncBarrier(long participantCount)
  • public long AddParticipant()
  • public long AddParticipants(long participantCount)
  • protected virtual Task PostPhase(long phase)
  • public void RemoveParticipant()
  • public void RemoveParticipants(long participantCount)
  • public Task<bool> SignalAndWaitAsync(TimeSpan timeout, CancellationToken token = default)
  • public Task SignalAndWaitAsync(CancellationToken token)
  • public Task SignalAndWaitAsync()
  • public Task<bool> WaitAsync(TimeSpan timeout, CancellationToken token)
• public static class AsyncBridge
  • public static CancellationTokenFuture WaitAsync(this CancellationToken token, bool completeAsCanceled = false)
  • public static WaitHandleFuture WaitAsync(this WaitHandle handle, TimeSpan timeout)
  • public static WaitHandleFuture WaitAsync(this WaitHandle handle)
• public class AsyncCountdownEvent : Synchronizer, IAsyncEvent, ISynchronizer, IDisposable
  • public long CurrentCount { get; }
  • public long InitialCount { get; }
  • public AsyncCountdownEvent(long initialCount)
  • public void AddCount(long signalCount)
  • public void AddCount()
  • public bool Reset()
  • public bool Reset(long count)
  • public bool Signal(long signalCount)
  • public bool Signal()
  • public bool TryAddCount(long signalCount)
  • public bool TryAddCount()
• public class AsyncCounter : QueuedSynchronizer, IAsyncEvent, ISynchronizer, IDisposable
  • public long Value { get; }
  • public AsyncCounter(long initialValue = 0)
  • public void Increment()
  • public Task<bool> WaitAsync(TimeSpan timeout, CancellationToken token)
• public static class AsyncEvent
  • public static Task<bool> WaitAsync(this IAsyncEvent event, TimeSpan timeout)
  • public static Task WaitAsync(this IAsyncEvent event, CancellationToken token)
  • public static Task WaitAsync(this IAsyncEvent event)
• public class AsyncExclusiveLock : QueuedSynchronizer, IAsyncDisposable
  • public Task Acquire(TimeSpan timeout)
  • public Task Acquire(CancellationToken token)
  • public Task AcquireAsync(TimeSpan timeout, CancellationToken token = default)
  • public Task AcquireAsync(CancellationToken token)
  • public ValueTask DisposeAsync()
  • public Task<bool> TryAcquire(TimeSpan timeout, CancellationToken token)
  • public Task<bool> TryAcquire(TimeSpan timeout)
  • public bool TryAcquire()
  • public Task<bool> TryAcquireAsync(TimeSpan timeout, CancellationToken token)
  • public Task<bool> TryAcquireAsync(TimeSpan timeout)
• public class AsyncLazy<T>
  • public bool IsValueCreated { get; }
  • public Task<T> Task { get; }
  • public Result<T>? Value { get; }
  • public AsyncLazy(T value)
  • public AsyncLazy(ValueFunc<Task<T>> valueFactory, bool resettable = false)
  • public AsyncLazy(Func<Task<T>> valueFactory, bool resettable = false)
  • public ConfiguredTaskAwaitable<T> ConfigureAwait(bool continueOnCapturedContext)
  • public TaskAwaiter<T> GetAwaiter()
  • public bool Reset()
• public struct AsyncLock : IDisposable, IEquatable<AsyncLock>, IAsyncDisposable
  • public static AsyncLock Exclusive(AsyncSharedLock lock)
  • public static AsyncLock Weak(AsyncSharedLock lock)
  • public Task<Holder> Acquire(CancellationToken token)
  • public Task<Holder> Acquire(TimeSpan timeout)
  • public Task<Holder> AcquireAsync(CancellationToken token)
  • public Task<Holder> AcquireAsync(TimeSpan timeout, CancellationToken token = default)
  • public ValueTask DisposeAsync()
  • public Task<Holder> TryAcquire(TimeSpan timeout)
  • public Task<Holder> TryAcquire(TimeSpan timeout, CancellationToken token)
  • public Task<Holder> TryAcquireAsync(TimeSpan timeout, bool suppressCancellation, CancellationToken token)
  • public Task<Holder> TryAcquireAsync(TimeSpan timeout, CancellationToken token = default)
  • public Task<Holder> TryAcquireAsync(CancellationToken token)
• public static class AsyncLockAcquisition
  • public static Task<Holder> AcquireLock(this AsyncExclusiveLock lock, CancellationToken token)
  • public static Task<Holder> AcquireLock(this AsyncExclusiveLock lock, TimeSpan timeout)
  • public static Task<Holder> AcquireLockAsync(this SemaphoreSlim semaphore, CancellationToken token)
  • public static Task<Holder> AcquireLockAsync(this SemaphoreSlim semaphore, TimeSpan timeout)
  • public static Task<Holder> AcquireReadLock(this AsyncReaderWriterLock rwLock, TimeSpan timeout)
  • public static Task<Holder> AcquireReadLock(this AsyncReaderWriterLock rwLock, CancellationToken token)
  • public static Task<Holder> AcquireUpgradeableReadLock(this AsyncReaderWriterLock rwLock, TimeSpan timeout)
  • public static Task<Holder> AcquireUpgradeableReadLock(this AsyncReaderWriterLock rwLock, CancellationToken token)
  • public static Task<Holder> AcquireWriteLock(this AsyncReaderWriterLock rwLock, TimeSpan timeout)
  • public static Task<Holder> AcquireWriteLock(this AsyncReaderWriterLock rwLock, CancellationToken token)
• public abstract class AsyncLockBase : Disposable
• public class AsyncManualResetEvent : Synchronizer, IAsyncResetEvent, IAsyncEvent, ISynchronizer, IDisposable
  • public AsyncManualResetEvent(bool initialState)
  • public bool Reset()
  • public bool Set()
  • public bool Set(bool autoReset)
• public class AsyncReaderWriterLock : QueuedSynchronizer, IAsyncDisposable
  • public struct LockStamp : IEquatable<LockStamp>
  • public Task EnterReadLock(CancellationToken token)
  • public Task EnterReadLock(TimeSpan timeout)
  • public Task EnterUpgradeableReadLock(CancellationToken token)
  • public Task EnterUpgradeableReadLock(TimeSpan timeout)
  • public Task EnterWriteLock(CancellationToken token)
  • public Task EnterWriteLock(TimeSpan timeout)
  • public ValueTask DisposeAsync()
  • public Task EnterReadLockAsync(CancellationToken token)
  • public Task EnterReadLockAsync(TimeSpan timeout, CancellationToken token = default)
  • public Task EnterUpgradeableReadLockAsync(CancellationToken token)
  • public Task EnterUpgradeableReadLockAsync(TimeSpan timeout, CancellationToken token = default)
  • public Task EnterWriteLockAsync(CancellationToken token)
  • public Task EnterWriteLockAsync(TimeSpan timeout, CancellationToken token = default)
  • public Task<bool> TryEnterReadLock(TimeSpan timeout, CancellationToken token)
  • public Task<bool> TryEnterReadLock(TimeSpan timeout)
  • public Task<bool> TryEnterUpgradeableReadLock(TimeSpan timeout, CancellationToken token)
  • public Task<bool> TryEnterUpgradeableReadLock(TimeSpan timeout)
  • public Task<bool> TryEnterWriteLock(TimeSpan timeout, CancellationToken token)
  • public Task<bool> TryEnterWriteLock(TimeSpan timeout)
  • public bool TryEnterReadLock()
  • public Task<bool> TryEnterReadLockAsync(TimeSpan timeout, CancellationToken token)
  • public Task<bool> TryEnterReadLockAsync(TimeSpan timeout)
  • public bool TryEnterUpgradeableReadLock()
  • public Task<bool> TryEnterUpgradeableReadLockAsync(TimeSpan timeout, CancellationToken token)
  • public Task<bool> TryEnterUpgradeableReadLockAsync(TimeSpan timeout)
  • public bool TryEnterWriteLock(ref LockStamp stamp)
  • public bool TryEnterWriteLock()
  • public Task<bool> TryEnterWriteLockAsync(TimeSpan timeout, CancellationToken token)
  • public Task<bool> TryEnterWriteLockAsync(TimeSpan timeout)
  • public LockStamp TryOptimisticRead()
• public class AsyncResetEvent : AsyncLockBase
• public class AsyncSharedLock : QueuedSynchronizer, IAsyncDisposable
  • public long ConcurrencyLevel { get; }
  • public bool IsLockHeld { get; }
  • public long RemainingCount { get; }
  • public AsyncSharedLock(long concurrencyLevel)
  • public Task AcquireAsync(bool strongLock, TimeSpan timeout, CancellationToken token = default)
  • public Task AcquireAsync(bool strongLock, CancellationToken token)
  • public ValueTask DisposeAsync()
  • public void Downgrade()
  • public void Release()
  • public bool TryAcquire(bool strongLock)
  • public Task<bool> TryAcquireAsync(bool strongLock, TimeSpan timeout, CancellationToken token)
  • public Task<bool> TryAcquireAsync(bool strongLock, TimeSpan timeout)
• public class AsyncTimer : Disposable
  • public bool IsRunning { get; }
  • public AsyncTimer(ValueFunc<CancellationToken, Task<bool>> callback)
  • public AsyncTimer(Func<CancellationToken, Task<bool>> callback)
  • public bool Start(TimeSpan dueTime, TimeSpan period, CancellationToken token = default)
  • public bool Start(TimeSpan period, CancellationToken token = default)
  • public Task<bool> StopAsync()
• public class AsyncTrigger : QueuedSynchronizer, IAsyncEvent, ISynchronizer, IDisposable
  • public AsyncTrigger()
  • public void Signal()
  • public void Signal<TState>(TState state)
  • public void Signal<TState, TArgs>(TState state, Action<TState, TArgs> mutator, TArgs args)
  • public void Signal<TState>(TState state, Action<TState> mutator)
  • public Task<bool> SignalAndWaitAsync<TState>(TState state, Predicate<TState> condition, TimeSpan timeout, CancellationToken token = default)
  • public Task SignalAndWaitAsync<TState>(TState state, Predicate<TState> condition, CancellationToken token = default)
  • public Task<bool> SignalAndWaitAsync<TState, TArgs>(TState state, Action<TState, TArgs> mutator, TArgs args, Predicate<TState> condition, TimeSpan timeout, CancellationToken token = default)
  • public Task SignalAndWaitAsync<TState, TArgs>(TState state, Action<TState, TArgs> mutator, TArgs args, Predicate<TState> condition, CancellationToken token = default)
  • public Task<bool> SignalAndWaitAsync<TState>(TState state, Action<TState> mutator, Predicate<TState> condition, TimeSpan timeout, CancellationToken token = default)
  • public Task SignalAndWaitAsync<TState>(TState state, Action<TState> mutator, Predicate<TState> condition, CancellationToken token = default)
  • public Task<bool> WaitAsync(TimeSpan timeout, CancellationToken token = default)
  • public Task<bool> WaitAsync<TState>(TState state, Predicate<TState> condition, TimeSpan timeout, CancellationToken token = default)
  • public Task WaitAsync<TState>(TState state, Predicate<TState> condition, CancellationToken token = default)
• public class ConcurrentObjectPool<T> : Disposable
  • public struct Rental<T>
  • protected readonly IReadOnlyList<T> objects
  • public ConcurrentObjectPool(IList<T> objects)
  • public Rental<T> Rent()
  • public interface IRental<T> : IDisposable
  • public int Capacity { get; }
  • public int WaitCount { get; }
  • public ConcurrentObjectPool(int capacity, ValueFunc<T> factory)
  • public ConcurrentObjectPool(int capacity, Func<T> factory)
  • public ConcurrentObjectPool(IEnumerable<T> objects)
  • public IRental<T> Rent(CancellationToken token)
  • public IRental<T> Rent()
• public interface IAsyncEvent : ISynchronizer, IDisposable
  • bool IsSet { get; }
  • bool Reset()
  • bool Signal()
  • Task<bool> WaitAsync(TimeSpan timeout, CancellationToken token)
• public interface IAsyncResetEvent : IAsyncEvent, ISynchronizer, IDisposable
  • EventResetMode ResetMode { get; }
• public interface ISynchronizer
  • bool HasWaiters { get; }
• public static class LinkedTokenSourceFactory
  • public static CancellationTokenSource LinkTo(this ref CancellationToken first, CancellationToken second)
• public abstract class QueuedSynchronizer : Disposable, ISynchronizer
  • public void CancelSuspendedCallers(CancellationToken token)
• public abstract class Synchronizer : Disposable, ISynchronizer
  • public bool IsSet { get; }
  • public Task<bool> WaitAsync(TimeSpan timeout, CancellationToken token)
  • public Task<bool> WaitAsync<T>(Predicate<T> condition, T arg, TimeSpan timeout, CancellationToken token = default)
  • public Task WaitAsync<T>(Predicate<T> condition, T arg, CancellationToken token = default)
  • public Task<bool> WaitAsync<T1, T2>(Func<T1, T2, bool> condition, T1 arg1, T2 arg2, TimeSpan timeout, CancellationToken token = default)
  • public Task WaitAsync<T1, T2>(Func<T1, T2, bool> condition, T1 arg1, T2 arg2, CancellationToken token = default)

DotNext.Threading.Channels

• public abstract class PersistentChannel<TInput, TOutput> : Channel<TInput, TOutput>, IChannelWriter<TInput>, IChannel, IChannelReader<TOutput>, IDisposable
  • public long RemainingCount { get; }
  • public double Throughput { get; }
  • protected PersistentChannel(PersistentChannelOptions options)
  • protected abstract ValueTask<TOutput> DeserializeAsync(Stream input, CancellationToken token)
  • protected virtual void Dispose(bool disposing)
  • public void Dispose()
  • protected abstract ValueTask SerializeAsync(TInput input, Stream output, CancellationToken token)
• public sealed class PersistentChannelOptions : ChannelOptions
  • public int BufferSize { get; set; }
  • public long InitialPartitionSize { get; set; }
  • public string Location { get; set; }
  • public int PartitionCapacity { get; set; }
  • public PersistentChannelOptions()

DotNext.Threading.Tasks

• public static class ValueTaskSynchronization
  • public static ValueTask<ValueTask<R>> WhenAny<R>(ValueTask<R> task1, ValueTask<R> task2)
  • public static ValueTask<ValueTask<TResult>> WhenAny<TResult>(ValueTask<TResult> task1, ValueTask<TResult> task2)
  • public static ValueTask<ValueTask<R>> WhenAny<R>(ValueTask<R> task1, ValueTask<R> task2, ValueTask<R> task3)
  • public static ValueTask<ValueTask<TResult>> WhenAny<TResult>(ValueTask<TResult> task1, ValueTask<TResult> task2, ValueTask<TResult> task3)
  • public static ValueTask<ValueTask<R>> WhenAny<R>(ValueTask<R> task1, ValueTask<R> task2, ValueTask<R> task3, ValueTask<R> task4)
  • public static ValueTask<ValueTask<TResult>> WhenAny<TResult>(ValueTask<TResult> task1, ValueTask<TResult> task2, ValueTask<TResult> task3, ValueTask<TResult> task4)
  • public static ValueTask<ValueTask<R>> WhenAny<R>(ValueTask<R> task1, ValueTask<R> task2, ValueTask<R> task3, ValueTask<R> task4, ValueTask<R> task5)
  • public static ValueTask<ValueTask<TResult>> WhenAny<TResult>(ValueTask<TResult> task1, ValueTask<TResult> task2, ValueTask<TResult> task3, ValueTask<TResult> task4, ValueTask<TResult> task5)