DotNext by .NET Foundation and Contributors

<PackageReference Include="DotNext" Version="5.18.0" />

---

API Diff between 5.18.0 and 4.2.0-beta.2

673 Additions 147 Removals

DotNext

• public static class BasicExtensions
  • public static T As<T>(this T obj)
  • public static DisclosedEndpoint<T> Disclosed<T>(this T value) where T : IComparable<T>
  • public static EnclosedEndpoint<T> Enclosed<T>(this T value) where T : IComparable<T>
  • public static UserDataStorage GetUserData<T>(this T obj)
  • public static bool IsBetween<T, TLowerBound, TUpperBound>(this T value, TLowerBound lowerBound, TUpperBound upperBound) where TLowerBound : IRangeEndpoint<T> where TUpperBound : IRangeEndpoint<T>
  • public static bool IsNullOrEmpty(this Array array)
  • public static bool IsOneOf<T>(this T value, ReadOnlySpan<T> candidates)
  • public static bool TryGetValue<T>(this T? nullable, out T value) where T : struct
• public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int GetHashCode(ref T value, bool salted = true)
  • public static int GetHashCode(ref T value, int hash, Func<int, int, int> hashFunction, bool salted = true)
• public enum BoundType
• public abstract class CharComparer : IEqualityComparer<char>, IComparer<char>
  • protected CharComparer()
  • public static int Compare(char x, char y, StringComparison comparisonType)
  • public static CharComparer Create(CultureInfo culture, CompareOptions options)
  • public static bool Equals(char x, char y, StringComparison comparisonType)
  • public static CharComparer FromComparison(StringComparison comparison)
  • public static int GetHashCode(char ch, StringComparison comparisonType)
  • public abstract int Compare(char x, char y)
  • public abstract bool Equals(char x, char y)
  • public abstract int GetHashCode(char ch)
• public static class Comparison
• public static class DelegateHelpers
  • public static Func<bool> Bind<T>(this Predicate<T> predicate, T obj)
  • public static Action HideReturnValue<TResult>(this Func<TResult> func)
  • public static Action<T> HideReturnValue<T, TResult>(this Func<T, TResult> func)
  • public static Func<T, CancellationToken, ValueTask> ToAsync<T>(this Action<T> action)
  • public static Func<T, CancellationToken, ValueTask<TResult>> ToAsync<T, TResult>(this Func<T, TResult> action)
  • public static Func<CancellationToken, ValueTask> ToAsync(this Action action)
  • public static Func<CancellationToken, ValueTask<TResult>> ToAsync<TResult>(this Func<TResult> func)
  • public static Func<T1, T2, CancellationToken, ValueTask> ToAsync<T1, T2>(this Action<T1, T2> action)
  • public static Func<T1, T2, CancellationToken, ValueTask<TResult>> ToAsync<T1, T2, TResult>(this Func<T1, T2, TResult> func)
  • public static Predicate<T> Unbind<T>(this Func<bool> func)
• public struct DelegatingConsumer<T> : IConsumer<T>, IFunctional<Action<T>>, IEquatable<DelegatingConsumer<T>>
  • public static DelegatingConsumer<T> op_Implicit(Action<T> action)
• public struct DisclosedEndpoint<T> : IFiniteRangeEndpoint<T>, IRangeEndpoint<T> where T : IComparable<T>
  • public T Value { get; set; }
  • public static DisclosedEndpoint<T> op_Implicit(T value)
  • public static EnclosedEndpoint<T> op_OnesComplement(DisclosedEndpoint<T> endpoint)
• public abstract class Disposable : IDisposable
  • protected bool IsDisposing { get; }
  • protected bool IsDisposingOrDisposed { get; }
  • public static void Dispose(IDisposable[] objects)
  • public static void Dispose<T>(ReadOnlySpan<T> objects) where T : IDisposable
  • protected void ThrowIfDisposed()
  • protected bool TryBeginDispose()
• public struct EnclosedEndpoint<T> : IFiniteRangeEndpoint<T>, IRangeEndpoint<T> where T : IComparable<T>
  • public T Value { get; set; }
  • public static EnclosedEndpoint<T> op_Implicit(T value)
  • public static DisclosedEndpoint<T> op_OnesComplement(EnclosedEndpoint<T> endpoint)
• public static class EnumConverter
  • public static TValue FromEnum<TEnum, TValue>(TEnum value) where TEnum : struct, Enum where TValue : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), INumberBase<TValue>, IConvertible
  • public static byte ToByte<T>(T value) where T : struct, Enum
  • public static T ToEnum<T>(long value) where T : struct, Enum
  • public static T ToEnum<T>(int value) where T : struct, Enum
  • public static T ToEnum<T>(short value) where T : struct, Enum
  • public static T ToEnum<T>(byte value) where T : struct, Enum
  • public static T ToEnum<T>(sbyte value) where T : struct, Enum
  • public static T ToEnum<T>(ushort value) where T : struct, Enum
  • public static T ToEnum<T>(uint value) where T : struct, Enum
  • public static T ToEnum<T>(ulong value) where T : struct, Enum
  • public static short ToInt16<T>(T value) where T : struct, Enum
  • public static int ToInt32<T>(T value) where T : struct, Enum
  • public static long ToInt64<T>(T value) where T : struct, Enum
  • public static sbyte ToSByte<T>(T value) where T : struct, Enum
  • public static ushort ToUInt16<T>(T value) where T : struct, Enum
  • public static uint ToUInt32<T>(T value) where T : struct, Enum
  • public static ulong ToUInt64<T>(T value) where T : struct, Enum
  • public static TEnum ToEnum<TEnum, TValue>(TValue value) where TEnum : struct, Enum where TValue : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), INumberBase<TValue>, IConvertible
• public static class Func
  • public static Func<T, T> Identity<T>(this Action<T> action)
• public interface IFiniteRangeEndpoint<T> : IRangeEndpoint<T>
  • T Value { get; }
• public interface IOptionMonad<T> : ISupplier<object>, IFunctional<Func<object>>
  • T ValueOrDefault { get; }
  • T OrDefault()
• public interface IOptionMonad<T, TSelf> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>> where TSelf : struct, IOptionMonad<T, TSelf>
  • T op_Explicit(ref TSelf container)
  • bool op_False(ref TSelf container)
  • T op_Explicit(TSelf& modreq(System.Runtime.InteropServices.InAttribute) container)
  • bool op_True(ref TSelf container)
• public interface IRangeEndpoint<T>
  • IRangeEndpoint<T> Infinity { get; }
  • bool IsOnLeft(T value)
  • bool IsOnRight(T value)
• public interface IResettable
  • void Reset()
• public interface IResultMonad<T, TError, TSelf> : IResultMonad<T, TError>, IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>, IOptionMonad<T, TSelf> where TSelf : struct, IResultMonad<T, TError, TSelf>
  • Optional<T> op_Implicit(ref TSelf result)
• public interface ISupplier<TResult> : IFunctional<Func<TResult>>
  • ISupplier<TResult> NullOrDefault { get; }
• public static class ObjectExtensions
• public static class OneDimensionalArray
• public static class Optional
  • public static Optional<T> Create<T, TMonad>(TMonad value) where TMonad : struct, IOptionMonad<T>
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T, TException>(ref Optional optional) where T : struct where TException : Exception
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(ref Optional optional, Func<Exception> exceptionFactory) where T : struct
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(ref Optional optional, method exceptionFactory) where T : struct
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(ref Optional optional) where T : struct
• public struct Optional<T> : IEquatable<Optional<T>>, IEquatable<T>, IStructuralEquatable, IOptionMonad<T, Optional<T>>, IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>
  • public T ValueOrDefault { get; }
  • public T& modreq(System.Runtime.InteropServices.InAttribute) ValueRef { get; }
  • public static Optional<T> Create<TMonad>(TMonad value) where TMonad : struct, IOptionMonad<T>
  • public static T op_BitwiseOr(ref Optional optional, T defaultValue)
  • public Optional<ValueTuple<T, TOther>> Concat<TOther>(ref Optional other)
  • public T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<TException>() where TException : Exception
  • public T& modreq(System.Runtime.InteropServices.InAttribute) GetReference(Func<Exception> exceptionFactory)
  • public T& modreq(System.Runtime.InteropServices.InAttribute) GetReference(method exceptionFactory)
  • public T OrDefault()
• public static class Predicate
  • public static Predicate<T> False<T>()
  • public static Predicate<T> Constant<T>(bool value)
  • public static Predicate<T> True<T>()
• public static class RandomExtensions
  • public static void GetItems<T>(this Random random, Span<T> buffer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void GetItems<T>(this RandomNumberGenerator random, Span<T> buffer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void NextChars(this Random random, ReadOnlySpan<char> allowedChars, Span<char> buffer)
  • public static void NextChars(this RandomNumberGenerator random, ReadOnlySpan<char> allowedChars, Span<char> buffer)
  • public static Optional<T> Peek<T>(this Random random, IReadOnlyCollection<T> collection)
  • public static Optional<T> Peek<T>(this Random random, ReadOnlySpan<T> span)
  • public static void Shuffle<T>(this Random random, IList<T> list)
• public static class Result
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(ref Result result)
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T, TError>(ref Result result) where TError : struct, Enum
• public struct Result<T> : IResultMonad<T, Exception, Result<T>>, IResultMonad<T, Exception>, IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>, IOptionMonad<T, Result<T>>
  • public T ValueOrDefault { get; }
  • public T& modreq(System.Runtime.InteropServices.InAttribute) ValueRef { get; }
  • public static T op_BitwiseOr(ref Result result, T defaultValue)
  • public static Result<T> op_BitwiseOr(ref Result x, ref Result y)
  • public static ValueTask<T> op_Explicit(ref Result result)
  • public ValueTask<T> AsTask()
  • public T OrDefault()
• public struct Result<T, TError> : IResultMonad<T, TError, Result<T, TError>>, IResultMonad<T, TError>, IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>, IOptionMonad<T, Result<T, TError>> where TError : struct, Enum
  • public T ValueOrDefault { get; }
  • public T& modreq(System.Runtime.InteropServices.InAttribute) ValueRef { get; }
  • public static T op_BitwiseOr(ref Result result, T defaultValue)
  • public static Result<T, TError> op_BitwiseOr(ref Result x, ref Result y)
  • public T OrDefault()
• public static class Span
  • public static ReadOnlySpan<T> Advance<T>(this ref ReadOnlySpan source, int count)
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) Advance<T>(this ref ReadOnlySpan source)
  • public static Span<T> Advance<T>(this ref Span source, int count)
  • public static ref T Advance<T>(this ref Span source)
  • public static int BitwiseCompare<T>(this Span<T> first, Span<T> second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static bool BitwiseEquals<T>(this Span<T> first, Span<T> second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this Span<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this ReadOnlySpan<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this Span<T> span, int hash, Func<int, int, int> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T, THashFunction>(this Span<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where THashFunction : struct, IConsumer<int>, ISupplier<int>
  • public static int BitwiseHashCode<T>(this ReadOnlySpan<T> span, int hash, Func<int, int, int> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T, THashFunction>(this ReadOnlySpan<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where THashFunction : struct, IConsumer<int>, ISupplier<int>
  • public static long BitwiseHashCode64<T>(this Span<T> span, long hash, Func<long, long, long> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T, THashFunction>(this Span<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where THashFunction : struct, IConsumer<long>, ISupplier<long>
  • public static long BitwiseHashCode64<T>(this ReadOnlySpan<T> span, long hash, Func<long, long, long> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T, THashFunction>(this ReadOnlySpan<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where THashFunction : struct, IConsumer<long>, ISupplier<long>
  • public static long BitwiseHashCode64<T>(this Span<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this ReadOnlySpan<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static bool CheckMask<T>(this ReadOnlySpan<T> value, ReadOnlySpan<T> mask) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static MemoryOwner<char> Concat(ReadOnlySpan<string> values, MemoryAllocator<char> allocator = null)
  • public static ReadOnlySpan<TBase> Contravariance<T, TBase>(this ReadOnlySpan<T> span) where T : TBase
  • public static Optional<T> FirstOrEmpty<T>(this ReadOnlySpan<T> span)
  • public static Optional<T> FirstOrNone<T>(this ReadOnlySpan<T> span)
  • public static int FromHex(this ReadOnlySpan<char> chars, Span<byte> output)
  • public static byte[] FromHex(this ReadOnlySpan<char> chars)
  • public static Optional<T> PeekRandom<T>(this ReadOnlySpan<T> span, Random random)
  • public static void Shuffle<T>(this Span<T> span, Random random)
  • public static bool IsBitwiseAndNonZero<T>(this ReadOnlySpan<T> value, ReadOnlySpan<T> mask) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Move<T>(this Span<T> span, Range range, Index destinationIndex)
  • public static int ToHex(this ReadOnlySpan<byte> bytes, Span<char> output, bool lowercased = false)
  • public static string ToHex(this ReadOnlySpan<byte> bytes, bool lowercased = false)
  • public static void Swap<T>(this Span<T> x, Span<T> y)
  • public static void Swap<T>(this Span<T> span, Range range1, Range range2)
  • public static Span<T> TrimLength<T>(this Span<T> span, int maxLength, out Span rest)
• public static class StringExtensions
  • public static MemoryTemplate<char> AsTemplate(this string template, string placeholder)
  • public static MemoryTemplate<char> AsTemplate(this string template, char placeholder)
  • public static string IfNullOrEmpty(this string str, string alt)
  • public static bool IsNullOrEmpty(this StringBuilder builder)
• public struct UserDataSlot<TValue> : IEquatable<UserDataSlot<TValue>>
  • public static UserDataSlot<TValue> Allocate()
• public static class ValueTypeExtensions

DotNext.Buffers

• public static class BufferHelpers
• public abstract class BufferWriter<T> : Disposable, IBufferWriter<T>, ISupplier<ReadOnlyMemory<T>>, IFunctional<Func<ReadOnlyMemory<T>>>, IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IGrowableBuffer<T>, IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>, IDisposable, IResettable
  • public void Rewind(int count)
• public struct BufferWriterSlim<T>
  • public ref T Add()
  • public void AddAll(IEnumerable<T> collection)
  • public MemoryOwner<T> DetachOrCopyBuffer()
  • public void Rewind(int count)
  • public bool TryPeek(out T item)
  • public bool TryPop(out T item)
  • public bool TryPop(Span<T> output)
• public static class ByteBuffer
  • public static int Format<T>(this IBufferWriter<byte> writer, T value, ReadOnlySpan<char> format = default, IFormatProvider provider = null) where T : IUtf8SpanFormattable
  • public static int Format<T>(this ref BufferWriterSlim writer, T value, ReadOnlySpan<char> format = default, IFormatProvider provider = null) where T : IUtf8SpanFormattable
  • public static T Read<T>(this ref SpanReader reader) where T : IBinaryFormattable<T>
  • public static T ReadBigEndian<T>(this ref SpanReader reader) where T : IBinaryInteger<T>
  • public static T ReadLeb128<T>(this ref SpanReader reader) where T : struct, IBinaryInteger<T>
  • public static T ReadLittleEndian<T>(this ref SpanReader reader) where T : IBinaryInteger<T>
  • public static bool TryEncodeAsUtf8(this ref SpanWriter writer, ReadOnlySpan<char> input)
  • public static bool TryFormat<T>(this ref SpanWriter writer, T value, ReadOnlySpan<char> format = default, IFormatProvider provider = null) where T : IUtf8SpanFormattable
  • public static bool TryRead<T>(this ref SpanReader reader, out T value) where T : IBinaryFormattable<T>
  • public static bool TryWrite<T>(this ref SpanWriter writer, T value) where T : IBinaryFormattable<T>
  • public static bool TryWrite(this ref SpanWriter writer, ref BigInteger value, bool isBigEndian = false, bool isUnsigned = false)
  • public static void Write<T>(this IBufferWriter<byte> writer, T value) where T : IBinaryFormattable<T>
  • public static int Write(this IBufferWriter<byte> writer, ref BigInteger value, bool isBigEndian = false, bool isUnsigned = false)
  • public static void Write<T>(this ref BufferWriterSlim writer, T value) where T : IBinaryFormattable<T>
  • public static int Write(this ref BufferWriterSlim writer, ref BigInteger value, bool isBigEndian = false, bool isUnsigned = false)
  • public static void Write<T>(this ref SpanWriter writer, T value) where T : IBinaryFormattable<T>
  • public static int WriteBigEndian<T>(this IBufferWriter<byte> writer, T value) where T : IBinaryInteger<T>
  • public static int WriteBigEndian<T>(this ref BufferWriterSlim writer, T value) where T : IBinaryInteger<T>
  • public static int WriteBigEndian<T>(this ref SpanWriter writer, T value) where T : IBinaryInteger<T>
  • public static int WriteLeb128<T>(this ref SpanWriter writer, T value) where T : struct, IBinaryInteger<T>
  • public static int WriteLeb128<T>(this ref BufferWriterSlim writer, T value) where T : struct, IBinaryInteger<T>
  • public static int WriteLittleEndian<T>(this IBufferWriter<byte> writer, T value) where T : IBinaryInteger<T>
  • public static int WriteLittleEndian<T>(this ref BufferWriterSlim writer, T value) where T : IBinaryInteger<T>
  • public static int WriteLittleEndian<T>(this ref SpanWriter writer, T value) where T : IBinaryInteger<T>
• public static class CharBuffer
  • public static void Concat(this IBufferWriter<char> writer, ReadOnlySpan<string> values)
  • public static void Concat(this ref BufferWriterSlim writer, ReadOnlySpan<string> values)
  • public static int Format<T>(this IBufferWriter<char> writer, T value, string format = null, IFormatProvider provider = null)
  • public static int Format(this IBufferWriter<char> writer, CompositeFormat format, ReadOnlySpan<object> args, IFormatProvider provider = null)
  • public static int Format<T>(this ref BufferWriterSlim writer, T value, string format = null, IFormatProvider provider = null)
  • public static int Format(this ref BufferWriterSlim writer, CompositeFormat format, ReadOnlySpan<object> args, IFormatProvider provider = null)
  • public static int Interpolate(this IBufferWriter<char> writer, IFormatProvider provider, ref BufferWriterInterpolatedStringHandler handler)
  • public static int Interpolate(this IBufferWriter<char> writer, ref BufferWriterInterpolatedStringHandler handler)
  • public static int Interpolate(this ref BufferWriterSlim writer, IFormatProvider provider, ref BufferWriterSlimInterpolatedStringHandler handler)
  • public static int Interpolate(this ref BufferWriterSlim writer, ref BufferWriterSlimInterpolatedStringHandler handler)
  • public static bool TryFormat<T>(this ref SpanWriter writer, T value, ReadOnlySpan<char> format = default, IFormatProvider provider = null) where T : ISpanFormattable
  • public static bool TryFormat(this ref SpanWriter writer, CompositeFormat format, ReadOnlySpan<object> args, IFormatProvider provider = null)
  • public static void Write(this IBufferWriter<char> writer, StringBuilder input)
  • public static void Write(this ref BufferWriterSlim writer, StringBuilder input)
  • public static void Write(this ref SpanWriter writer, StringBuilder input)
  • public static void WriteLine(this IBufferWriter<char> writer)
  • public static void WriteLine(this IBufferWriter<char> writer, ReadOnlySpan<char> characters)
  • public static void WriteLine(this ref BufferWriterSlim writer)
  • public static void WriteLine(this ref BufferWriterSlim writer, ReadOnlySpan<char> characters)
• public interface IBinaryFormattable<TSelf> where TSelf : IBinaryFormattable<TSelf>
• public static class MemoryAllocator
• public static class Memory
  • public static MemoryOwner<T> AllocateAtLeast<T>(this MemoryAllocator<T> allocator, int length)
  • public static MemoryOwner<T> AllocateAtLeast<T>(int length)
  • public static MemoryOwner<T> AllocateExactly<T>(this MemoryAllocator<T> allocator, int length)
  • public static MemoryOwner<T> AllocateExactly<T>(int length)
  • public static ReadOnlySequence<T> Concat<T>(this ReadOnlyMemory<T> first, ReadOnlyMemory<T> second)
  • public static void CopyTo<T>(this ref ReadOnlySequence source, Span<T> destination, out int writtenCount)
  • public static MemoryAllocator<T> GetArrayAllocator<T>()
  • public static MemoryAllocator<T> GetPinnedArrayAllocator<T>() where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static ref T GetReference<T>(ref MemoryOwner owner)
  • public static void ReleaseAll<T>(this ref MemoryOwner owner) where T : IDisposable
  • public static void Resize<T>(this ref MemoryOwner owner, int newLength, MemoryAllocator<T> allocator = null)
  • public static MemoryAllocator<T> ToAllocator<T>(this ArrayPool<T> pool)
  • public static MemoryAllocator<T> ToAllocator<T>(this MemoryPool<T> pool)
  • public static MemoryAllocator<T> ToAllocator<T>(this Func<int, IMemoryOwner<T>> provider)
  • public static ReadOnlySequence<T> ToReadOnlySequence<T>(this IEnumerable<ReadOnlyMemory<T>> chunks)
  • public static ReadOnlySequence<T> ToReadOnlySequence<T>(ReadOnlySpan<ReadOnlyMemory<T>> chunks)
  • public static ReadOnlySequence<char> ToReadOnlySequence(this IEnumerable<string> strings)
  • public static ReadOnlySequence<char> ToReadOnlySequence(ReadOnlySpan<string> strings)
  • public static ReadOnlySequence<char> ToReadOnlySequence(this StringBuilder builder)
  • public static ReadOnlyMemory<T> TrimLength<T>(this ReadOnlyMemory<T> memory, int maxLength)
  • public static Memory<T> TrimLength<T>(this Memory<T> memory, int maxLength)
  • public static bool TryGetBlock<T>(this ref ReadOnlySequence sequence, int count, out ReadOnlyMemory span)
• public struct MemoryOwner<T> : IMemoryOwner<T>, IDisposable, ISupplier<Memory<T>>, IFunctional<Func<Memory<T>>>, ISupplier<ReadOnlyMemory<T>>, IFunctional<Func<ReadOnlyMemory<T>>>
  • public ref T this[IntPtr index] { get; }
  • public static MemoryOwner<T> Create<TArg>(method provider, int length, TArg arg, bool exactSize = true)
• public struct MemoryRental<T>
• public static class MemoryTemplate
• public struct MemoryTemplate<T> where T : IEquatable<T>
• public sealed class PooledArrayBufferWriter<T> : BufferWriter<T>, ISupplier<ArraySegment<T>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
• public sealed class PooledBufferWriter<T> : BufferWriter<T>, IMemoryOwner<T>, IDisposable
• public sealed class PoolingArrayBufferWriter<T> : BufferWriter<T>, ISupplier<ArraySegment<T>>, IFunctional<Func<ArraySegment<T>>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
  • public ref T this[int index] { get; }
  • public ArraySegment<T> WrittenArray { get; }
  • public PoolingArrayBufferWriter(ArrayPool<T> pool = null)
  • public ArraySegment<T> GetArray(int sizeHint = 0)
  • public void Insert(int index, ReadOnlySpan<T> items)
  • public void Overwrite(int index, ReadOnlySpan<T> items)
  • public void RemoveFirst(int count)
  • public void RemoveLast(int count)
• public sealed class PoolingBufferWriter<T> : BufferWriter<T>, IMemoryOwner<T>, IDisposable
  • public PoolingBufferWriter(MemoryAllocator<T> allocator = null)
• public struct PoolingInterpolatedStringHandler : IGrowableBuffer<char>, IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IDisposable, IResettable
  • public PoolingInterpolatedStringHandler(int literalLength, int formattedCount, MemoryAllocator<char> allocator, IFormatProvider provider = null)
  • public void AppendFormatted<T>(T value, string format = null)
  • public void AppendFormatted(ReadOnlySpan<char> value, int alignment)
  • public void AppendFormatted<T>(T value, int alignment, string format = null)
  • public void AppendFormatted(ReadOnlySpan<char> value)
  • public void AppendLiteral(string value)
  • public void Dispose()
• public struct SpanOwner<T>
  • public static int StackallocThreshold { get; }
  • public bool IsEmpty { get; }
  • public ref T this[int index] { get; }
  • public int Length { get; }
  • public Span<T> Span { get; }
  • public SpanOwner(Span<T> span)
  • public SpanOwner(Span<T> span, int length)
  • public SpanOwner(MemoryPool<T> pool, int minBufferSize, bool exactSize = true)
  • public SpanOwner(MemoryPool<T> pool)
  • public SpanOwner(int minBufferSize, bool exactSize = true)
  • public static SpanOwner<T> op_Implicit(Span<T> span)
  • public void Dispose()
  • public ref T GetPinnableReference()
• public struct SpanReader<T>
  • public T Read()
  • public T& modreq(System.Runtime.InteropServices.InAttribute) Read()
• public struct SpanWriter<T>
  • public ref T Add()
  • public Span<T> SlideToEnd()
• public class SparseBufferWriter<T> : Disposable, IGrowableBuffer<T>, IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>, IDisposable, IResettable, ISupplier<ReadOnlySequence<T>>, IFunctional<Func<ReadOnlySequence<T>>>, IEnumerable<ReadOnlyMemory<T>>, IEnumerable, IBufferWriter<T>
  • public SequencePosition End { get; }
  • public SequencePosition Start { get; }
  • public int CopyTo(Span<T> output, ref SequencePosition position)
  • public void CopyTo<TConsumer>(TConsumer consumer, SequencePosition start) where TConsumer : IReadOnlySpanConsumer<T>
  • public long CopyTo<TConsumer>(TConsumer consumer, ref SequencePosition position, long count) where TConsumer : IReadOnlySpanConsumer<T>
  • public SequencePosition GetPosition(long offset, SequencePosition origin = default)
  • public ReadOnlySequence<T> Read(ref SequencePosition position, long count)

DotNext.Buffers.Binary

• public static class BinaryTransformations
  • public static void AndNot<T>(this ReadOnlySpan<T> x, Span<T> y) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void BitwiseAnd<T>(this ReadOnlySpan<T> x, Span<T> y) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void BitwiseOr<T>(this ReadOnlySpan<T> x, Span<T> y) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void BitwiseXor<T>(this ReadOnlySpan<T> x, Span<T> y) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void OnesComplement<T>(this Span<T> values) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Reverse<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public struct Blittable<T> : IBinaryFormattable<Blittable<T>> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public T Value
• public interface IBinaryFormattable<TSelf> where TSelf : IBinaryFormattable<TSelf>
  • int Size { get; }
  • MemoryOwner<byte> Format(TSelf value, MemoryAllocator<byte> allocator = null)
  • TSelf Parse(ReadOnlySpan<byte> source)
  • TSelf Parse(ref ReadOnlySequence source)
  • bool TryFormat(TSelf value, Span<byte> destination)
  • bool TryParse(ReadOnlySpan<byte> source, out TSelf result)
  • void Format(Span<byte> destination)
• public struct Leb128<T> : ISupplier<T>, IFunctional<Func<T>>, IResettable where T : struct, IBinaryInteger<T>
  • public struct Enumerator<T> where T : struct, IBinaryInteger<T>
  • public static int MaxSizeInBytes { get; }
  • public T Value { get; set; }
  • public static bool TryGetBytes(T value, Span<byte> buffer, out int bytesWritten)
  • public static bool TryParse(ReadOnlySpan<byte> buffer, out T result, out int bytesConsumed)
  • public bool Append(byte b)
  • public Enumerator<T> GetEnumerator()
  • public void Reset()

DotNext.Buffers.Text

• public struct Base64Decoder : IResettable
  • public bool NeedMoreData { get; }
  • public static IAsyncEnumerable<ReadOnlyMemory<byte>> DecodeFromUtf16Async(IAsyncEnumerable<ReadOnlyMemory<char>> chars, MemoryAllocator<byte> allocator = null, CancellationToken token = default)
  • public static IAsyncEnumerable<ReadOnlyMemory<byte>> DecodeFromUtf8Async(IAsyncEnumerable<ReadOnlyMemory<byte>> utf8Chars, MemoryAllocator<byte> allocator = null, CancellationToken token = default)
  • public void DecodeFromUtf16(ReadOnlySpan<char> chars, IBufferWriter<byte> bytes)
  • public MemoryOwner<byte> DecodeFromUtf16(ReadOnlySpan<char> chars, MemoryAllocator<byte> allocator = null)
  • public void DecodeFromUtf16(ReadOnlySpan<char> chars, ref BufferWriterSlim bytes)
  • public void DecodeFromUtf8(ReadOnlySpan<byte> chars, IBufferWriter<byte> bytes)
  • public MemoryOwner<byte> DecodeFromUtf8(ReadOnlySpan<byte> chars, MemoryAllocator<byte> allocator = null)
  • public void DecodeFromUtf8(ReadOnlySpan<byte> chars, ref BufferWriterSlim bytes)
  • public void Reset()
• public struct Base64Encoder : IResettable
  • public const int MaxBufferedDataSize = 2
  • public const int MaxCharsToFlush = 4
  • public const int MaxInputSize = 1610612731
  • public ReadOnlySpan<byte> BufferedData { get; }
  • public bool HasBufferedData { get; }
  • public static IAsyncEnumerable<ReadOnlyMemory<char>> EncodeToUtf16Async(IAsyncEnumerable<ReadOnlyMemory<byte>> bytes, MemoryAllocator<char> allocator = null, CancellationToken token = default)
  • public static IAsyncEnumerable<ReadOnlyMemory<byte>> EncodeToUtf8Async(IAsyncEnumerable<ReadOnlyMemory<byte>> bytes, MemoryAllocator<byte> allocator = null, CancellationToken token = default)
  • public MemoryOwner<char> EncodeToUtf16(ReadOnlySpan<byte> bytes, MemoryAllocator<char> allocator = null, bool flush = false)
  • public void EncodeToUtf16(ReadOnlySpan<byte> bytes, ref BufferWriterSlim chars, bool flush = false)
  • public void EncodeToUtf16(ReadOnlySpan<byte> bytes, IBufferWriter<char> chars, bool flush = false)
  • public MemoryOwner<byte> EncodeToUtf8(ReadOnlySpan<byte> bytes, MemoryAllocator<byte> allocator = null, bool flush = false)
  • public void EncodeToUtf8(ReadOnlySpan<byte> bytes, ref BufferWriterSlim chars, bool flush = false)
  • public void EncodeToUtf8(ReadOnlySpan<byte> bytes, IBufferWriter<byte> chars, bool flush = false)
  • public int Flush(Span<char> output)
  • public int Flush(Span<byte> output)
  • public void Reset()
• public static class Hex
  • public static int DecodeFromUtf16(ReadOnlySpan<char> chars, Span<byte> output)
  • public static int DecodeFromUtf8(ReadOnlySpan<byte> chars, Span<byte> output)
  • public static int EncodeToUtf16(ReadOnlySpan<byte> bytes, Span<char> output, bool lowercased = false)
  • public static string EncodeToUtf16(ReadOnlySpan<byte> bytes, bool lowercased = false)
  • public static int EncodeToUtf8(ReadOnlySpan<byte> bytes, Span<byte> output, bool lowercased = false)
  • public static byte[] EncodeToUtf8(ReadOnlySpan<byte> bytes, bool lowercased = false)

DotNext.Collections.Generic

• public static class AsyncEnumerable
  • public static Task<MemoryOwner<T>> CopyAsync<T>(this IAsyncEnumerable<T> enumerable, int sizeHint = 0, MemoryAllocator<T> allocator = null, CancellationToken token = default)
  • public static ValueTask<Optional<T>> ElementAtAsync<T>(this IAsyncEnumerable<T> collection, int index, CancellationToken token = default)
  • public static IAsyncEnumerable<T> Empty<T>()
  • public static ValueTask<Optional<T>> FirstOrNoneAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default)
  • public static ValueTask<Optional<T>> FirstOrNoneAsync<T>(this IAsyncEnumerable<T> seq, Predicate<T> filter, CancellationToken token = default)
  • public static ValueTask<T?> FirstOrNullAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default) where T : struct
  • public static ValueTask ForEachAsync<T>(this IAsyncEnumerable<T> collection, Action<T> action, CancellationToken token = default)
  • public static ValueTask ForEachAsync<T>(this IAsyncEnumerable<T> collection, Func<T, CancellationToken, ValueTask> action, CancellationToken token = default)
  • public static ValueTask<Optional<T>> LastOrNoneAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default)
  • public static ValueTask<T?> LastOrNullAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default) where T : struct
  • public static IAsyncEnumerable<T> Singleton<T>(T item)
  • public static ValueTask<bool> SkipAsync<T>(this IAsyncEnumerator<T> enumerator, int count)
  • public static IAsyncEnumerable<T> SkipNulls<T>(this IAsyncEnumerable<T> collection)
  • public static IAsyncEnumerable<T> Throw<T>(Exception e)
  • public static Task<T[]> ToArrayAsync<T>(this IAsyncEnumerable<T> collection, int initialCapacity = 10, MemoryAllocator<T> allocator = null, CancellationToken token = default)
• public static class Collection
  • public struct ConsumingEnumerable<T> : IEnumerable<T>, IEnumerable
  • public static IEnumerable<T> Append<T>(this IEnumerable<T> collection, T[] items)
  • public static Optional<T> PeekRandom<T>(this IReadOnlyCollection<T> collection, Random random)
  • public static MemoryOwner<T> Copy<T>(this IEnumerable<T> enumerable, int sizeHint = 0, MemoryAllocator<T> allocator = null)
  • public static bool ElementAt<T>(this IEnumerable<T> collection, int index, out T element)
  • public static Optional<T> FirstOrNone<T>(this IEnumerable<T> collection)
  • public static void ForEach<T>(this IEnumerable<T> collection, Action<T> action)
  • public static ValueTask ForEachAsync<T>(this IEnumerable<T> collection, Func<T, CancellationToken, ValueTask> action, CancellationToken token = default)
  • public static ConsumingEnumerable<T> GetConsumer<T>(this IProducerConsumerCollection<T> collection)
  • public static Optional<T> LastOrNone<T>(this IEnumerable<T> collection)
  • public static IEnumerable<T> Prepend<T>(this IEnumerable<T> collection, T[] items)
  • public static int SequenceHashCode<T>(this IEnumerable<T> sequence, bool salted = true)
  • public static IEnumerable<T> SkipNulls<T>(this IEnumerable<T> collection)
  • public static IAsyncEnumerable<T> ToAsyncEnumerable<T>(this IEnumerable<T> enumerable)
  • public static IAsyncEnumerator<T> ToAsyncEnumerator<TEnumerator, T>(this TEnumerator enumerator, CancellationToken token) where TEnumerator : struct, IEnumerator<TEnumerator, T>
  • public static IEnumerator<T> ToClassicEnumerator<TEnumerator, T>(this TEnumerator enumerator) where TEnumerator : struct, IEnumerator<TEnumerator, T>
  • public static string ToString<T>(this IEnumerable<T> collection, string delimiter, string ifEmpty = "")
• public static class Dictionary
  • public static IReadOnlyDictionary<TKey, TValue> Empty<TKey, TValue>()
• public static class Enumerator
  • public struct LimitedEnumerator<T> : IEnumerator<T>, IEnumerator, IDisposable
  • public static IAsyncEnumerator<T> GetAsyncEnumerator<T>(this IEnumerable<T> enumerable, CancellationToken token = default)
  • public static LimitedEnumerator<T> Limit<T>(this IEnumerator<T> enumerator, int count, bool leaveOpen = false)
  • public static bool Skip<T>(this IEnumerator<T> enumerator, int count)
  • public static bool Skip<TEnumerator, T>(this ref TEnumerator enumerator, int count) where TEnumerator : struct, IEnumerator<T>
  • public static IEnumerator<T> ToEnumerator<T>(ReadOnlyMemory<T> memory)
  • public static IEnumerator<T> ToEnumerator<T>(ref ReadOnlySequence sequence)
• public interface IEnumerator<TSelf, T> where TSelf : struct, IEnumerator<TSelf, T>
  • T Current { get; }
  • bool MoveNext()
  • void Reset()
• public static class List
  • public static void Shuffle<T>(this IList<T> list, Random random)
• public static class Sequence
• public static class Set
  • public static IReadOnlySet<T> Range<T, TLowerBound, TUpperBound>(TLowerBound lowerBound, TUpperBound upperBound) where T : IBinaryInteger<T> where TLowerBound : IFiniteRangeEndpoint<T> where TUpperBound : IFiniteRangeEndpoint<T>
  • public static IReadOnlySet<T> Singleton<T>(T item)

DotNext.Collections.Specialized

• public class ConcurrentTypeMap : ITypeMap, IReadOnlyTypeMap, IEnumerable<object>, IEnumerable
  • public struct Enumerator : IEnumerator<Enumerator, object>
  • public ConcurrentTypeMap(int capacity)
  • public ConcurrentTypeMap()
  • public bool AddOrUpdate<T>(T value)
  • public void Clear()
  • public bool Contains<T>()
  • public Enumerator GetEnumerator()
  • public T GetOrAdd<T>(T value, out bool added)
  • public bool Remove<T>()
  • public bool Remove<T>(out T value)
  • public void Set<T>(T value)
  • public bool Set<T>(T newValue, out T oldValue)
  • public bool TryAdd<T>(T value)
  • public bool TryGetValue<T>(out T value)
• public class ConcurrentTypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>, IEnumerable<TValue>, IEnumerable
  • public Optional<TValue> Replace<TKey>(TValue value)
  • public bool Set<TKey>(TValue newValue, out TValue oldValue)
• public static class InvocationList
  • public static ReadOnlySpan<TDelegate> AsSpan<TDelegate>(this ref InvocationList delegates) where TDelegate : MulticastDelegate
  • public static void Invoke<T>(this ref InvocationList actions, T arg)
  • public static void Invoke<T1, T2>(this ref InvocationList actions, T1 arg1, T2 arg2)
  • public static void Invoke<T>(this InvocationList<Action<T>> actions, T arg)
  • public static void Invoke<T1, T2>(this InvocationList<Action<T1, T2>> actions, T1 arg1, T2 arg2)
• public struct InvocationList<TDelegate> : IReadOnlyList<TDelegate>, IEnumerable<TDelegate>, IEnumerable, IReadOnlyCollection<TDelegate> where TDelegate : MulticastDelegate
  • public TDelegate this[int index] { get; }
  • public ReadOnlySpan<TDelegate> Span { get; }
• public interface IReadOnlyTypeMap : IEnumerable<object>, IEnumerable
  • bool Contains<T>()
  • bool TryGetValue<T>(out T value)
• public interface ITypeMap : IReadOnlyTypeMap, IEnumerable<object>, IEnumerable
  • void Add<T>(T value)
  • void Clear()
  • bool Remove<T>()
  • bool Remove<T>(out T value)
  • void Set<T>(T value)
  • bool Set<T>(T newValue, out T oldValue)
• public interface ITypeMap<TValue> : IReadOnlyTypeMap<TValue>
  • Optional<TValue> Replace<TKey>(TValue value)
  • bool Set<TKey>(TValue newValue, out TValue oldValue)
• public struct SingletonList<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IList<T>, ICollection<T>, ITuple, IReadOnlySet<T>, IAsyncEnumerable<T>
  • public T Item
  • public T Item { get; set; }
  • public SingletonList(T item)
• public class TypeMap : ITypeMap, IReadOnlyTypeMap, IEnumerable<object>, IEnumerable
  • public struct Enumerator : IEnumerator<Enumerator, object>
  • public TypeMap(int capacity)
  • public TypeMap()
  • public void Add<T>(T value)
  • public void Clear()
  • public bool Contains<T>()
  • public Enumerator GetEnumerator()
  • public ref T GetValueRefOrAddDefault<T>(out bool exists) where T : struct
  • public bool Remove<T>()
  • public bool Remove<T>(out T value)
  • public void Set<T>(T value)
  • public bool Set<T>(T newValue, out T oldValue)
  • public bool TryGetValue<T>(out T value)
• public class TypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>, IEnumerable<TValue>, IEnumerable
  • public Optional<TValue> Replace<TKey>(TValue value)
  • public bool Set<TKey>(TValue newValue, out TValue oldValue)

DotNext.ComponentModel.DataAnnotations

• public sealed class OptionalStringLengthAttribute : StringLengthAttribute
  • public OptionalStringLengthAttribute(int maximumLength)
• public sealed class RequiredAttribute<T> : RequiredAttribute
  • public bool AllowNull { get; set; }
  • public RequiredAttribute()

DotNext.Diagnostics

• public struct Timestamp : IComparable<Timestamp>, IComparisonOperators<Timestamp, Timestamp, bool>, IEqualityOperators<Timestamp, Timestamp, bool>, IAdditionOperators<Timestamp, TimeSpan, Timestamp>, ISubtractionOperators<Timestamp, TimeSpan, Timestamp>, IInterlockedOperations<Timestamp>, IEquatable<Timestamp>
  • public static Timestamp Current { get; }
  • public double ElapsedMilliseconds { get; }
  • public long ElapsedTicks { get; }
  • public Timestamp(TimeSpan ts)
  • public Timestamp(TimeProvider provider)
  • public static Timestamp CompareExchange(ref Timestamp location, Timestamp value, Timestamp comparand)
  • public static Timestamp op_CheckedAddition(Timestamp x, TimeSpan y)
  • public static Timestamp op_CheckedSubtraction(Timestamp x, TimeSpan y)
  • public static TimeSpan op_Explicit(Timestamp stamp)
  • public static TimeSpan op_Implicit(Timestamp stamp)
  • public static void Refresh(ref Timestamp location, TimeProvider provider)
  • public double ElapsedSince(Timestamp past)
  • public double ElapsedSince(Timestamp past, TimeProvider provider)
  • public double GetElapsedMilliseconds(TimeProvider provider)
  • public long GetElapsedTicks(TimeProvider provider)
  • public TimeSpan GetElapsedTime(TimeProvider provider)

DotNext.Generic

• public abstract class BooleanConst : Constant<bool>
• public abstract class Constant<T> : ISupplier<T>
• public sealed class DefaultConst<T> : Constant<T>
• public abstract class Int32Const : Constant<int>
• public abstract class Int64Const : Constant<long>
• public abstract class StringConst : Constant<string>

DotNext.IO

• public struct StreamConsumer : IReadOnlySpanConsumer<byte>, ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<byte>, CancellationToken, ValueTask>>, IEquatable<StreamConsumer>, IFlushable
  • public void Deconstruct(out Stream output)
• public static class StreamSource
  • public static Stream AsSharedStream(this ReadOnlySequence<byte> sequence, bool compatWithAsync = true)
  • public static Stream AsStream<TArg>(this Func<Memory<byte>, TArg, CancellationToken, ValueTask<int>> reader, TArg arg)
• public struct TextConsumer : IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IFlushable, IEquatable<TextConsumer>
  • public void Deconstruct(out TextWriter output)

DotNext.IO.Hashing

• public class FNV1a<THash, TParameters> : NonCryptographicHashAlgorithm, IResettable where THash : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), IBinaryNumber<THash> where TParameters : IFNV1aParameters<THash>
  • public FNV1a(bool salted = false)
  • public static THash Hash<T>(ReadOnlySpan<T> data, bool salted = false) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static THash Hash<T, TIndex>(Func<T, TIndex, THash> accessor, TIndex count, T arg, bool salted = false) where TIndex : IComparisonOperators<TIndex, TIndex, bool>, IAdditiveIdentity<TIndex, TIndex>, IIncrementOperators<TIndex>
  • public static THash Hash(Void* address, UIntPtr length, bool salted = false)
  • public static THash Hash(THash data)
  • public void Append<T>(ReadOnlySpan<T> source) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public void Append(Void* address, UIntPtr length)
  • public void Append(THash value)
  • public THash GetCurrentHash()
• public sealed class FNV1a128 : FNV1a<Int128, FNV1aParameters>
  • public FNV1a128(bool salted = false)
• public sealed class FNV1a32 : FNV1a<int, FNV1aParameters>
  • public FNV1a32(bool salted = false)
• public sealed class FNV1a64 : FNV1a<long, FNV1aParameters>
  • public FNV1a64(bool salted = false)
• public struct FNV1aParameters : IFNV1aParameters<int>, IFNV1aParameters<long>, IFNV1aParameters<Int128>
• public interface IFNV1aParameters<THash> where THash : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • THash Offset { get; }
  • THash Prime { get; }

DotNext.Net.Http

• public sealed class HttpEndPoint : DnsEndPoint, ISupplier<UriBuilder>, IFunctional<Func<UriBuilder>>, IEquatable<HttpEndPoint>, IEqualityOperators<HttpEndPoint, HttpEndPoint, bool>, ISpanFormattable, IFormattable, IParsable<HttpEndPoint>, IUtf8SpanFormattable
  • public string ToString(string format, IFormatProvider formatProvider)

DotNext.Numerics

• public static class BitVector
• public static class Number
  • public static TResult FromBits<TResult>(this ReadOnlySpan<bool> bits) where TResult : struct, INumber<TResult>, IBitwiseOperators<TResult, TResult, TResult>, IShiftOperators<TResult, int, TResult>
  • public static void GetBits<T>(this T value, Span<bool> bits) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), INumber<T>, IBitwiseOperators<T, T, T>, IShiftOperators<T, int, T>
  • public static int GetMaxByteCount<T>() where T : IBinaryInteger<T>
  • public static T GetPrime<T>(T lowerBound, ReadOnlySpan<T> cachedPrimes = default) where T : struct, IBinaryNumber<T>, ISignedNumber<T>, IMinMaxValue<T>, IShiftOperators<T, int, T>
  • public static bool IsBitSet<T>(this T number, int position) where T : struct, INumber<T>, IBitwiseOperators<T, T, T>, IShiftOperators<T, int, T>
  • public static bool IsPrime<T>(T value) where T : struct, IBinaryNumber<T>, ISignedNumber<T>, IShiftOperators<T, int, T>
  • public static bool IsSigned<T>() where T : INumberBase<T>
  • public static TOutput Normalize<TInput, TOutput>(this TInput value, TInput min, TInput max) where TInput : struct, INumberBase<TInput>, IComparisonOperators<TInput, TInput, bool> where TOutput : struct, IFloatingPoint<TOutput>
  • public static double Normalize(this ulong value)
  • public static double Normalize(this long value)
  • public static float Normalize(this uint value)
  • public static float Normalize(this int value)
  • public static T SetBit<T>(this T number, int position, bool value) where T : struct, INumber<T>, IBitwiseOperators<T, T, T>, IShiftOperators<T, int, T>

DotNext.Patterns

• public interface IBuildable<TSelf, TBuilder> where TSelf : IBuildable<TSelf, TBuilder> where TBuilder : ISupplier<TSelf>, IResettable
  • TBuilder CreateBuilder()
• public interface ISingleton<TSelf> where TSelf : ISingleton<TSelf>
  • TSelf Instance { get; }

DotNext.Reflection

• public static class PropertyExtensions
  • public static bool IsExternalInit(this PropertyInfo property)
• public static class TaskType
  • public static Func<bool> GetIsCompletedGetter(this Task task)
  • public static Type MakeTaskType(this Type taskResult)
• public static class TypeExtensions
  • public static object GetDefaultValue(this Type type)

DotNext.Runtime

• public static class BoxedValue
  • public static BoxedValue<T> Copy<T>(this BoxedValue<T> boxedValue) where T : struct
  • public static ref T Unbox<T>(this BoxedValue<T> boxedValue) where T : struct
• public abstract class BoxedValue<T> where T : struct
  • protected BoxedValue()
  • public static BoxedValue<T> Box(T value)
  • public static BoxedValue<T> GetTypedReference(object boxedValue)
  • public static BoxedValue<T> op_Explicit(T value)
  • public static BoxedValue<T> op_Explicit(ref Nullable value)
  • public static T op_Implicit(BoxedValue<T> boxedValue)
  • public static ValueType op_Implicit(BoxedValue<T> boxedValue)
  • public static ValueReference<T> op_Implicit(BoxedValue<T> boxedValue)
  • public static BoxedValue<T> TryBox(ref Nullable value)
  • public abstract bool Equals(object obj)
  • public abstract int GetHashCode()
  • public abstract string ToString()
• public struct GCLatencyModeScope : IDisposable
  • public static GCLatencyModeScope LowLatency { get; }
  • public static GCLatencyModeScope SustainedLowLatency { get; }
  • public GCLatencyModeScope(GCLatencyMode mode)
  • public void Dispose()
• public abstract class GCNotification
  • public struct Registration : IDisposable
  • public static GCNotification GCTriggered()
  • public static GCNotification GCTriggered(int generation)
  • public static GCNotification HeapCompaction()
  • public static GCNotification HeapFragmentation(double threshold)
  • public static GCNotification MemoryThreshold(double threshold)
  • public static GCNotification op_BitwiseAnd(GCNotification left, GCNotification right)
  • public static GCNotification op_BitwiseOr(GCNotification left, GCNotification right)
  • public static GCNotification op_ExclusiveOr(GCNotification left, GCNotification right)
  • public static GCNotification op_LogicalNot(GCNotification filter)
  • public virtual GCNotification And(GCNotification right)
  • public virtual GCNotification ExclusiveOr(GCNotification right)
  • public virtual GCNotification Negate()
  • public virtual GCNotification Or(GCNotification right)
  • public Registration Register<T>(Action<T, GCMemoryInfo> callback, T state, bool captureContext = false)
  • public Task<GCMemoryInfo> WaitAsync(TimeSpan timeout, CancellationToken token = default)
  • public Task<GCMemoryInfo> WaitAsync(CancellationToken token = default)
• public static class Intrinsics
  • public static bool AreSame<T>(ref T first, ref T second)
  • public static int AlignOf<T>()
  • public static bool AreCompatible<T1, T2>()
  • public static void Bitcast<T, TResult>(ref T input, out TResult output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where TResult : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void ClearBits(Void* address, IntPtr length)
  • public static int Compare(Void* first, Void* second, IntPtr length)
  • public static int Compare(Void* first, Void* second, UIntPtr length)
  • public static void Copy<T>(ref T source, out T destination, long count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Copy<T>(ref T source, out T destination, UIntPtr count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static T DefaultOf<T>()
  • public static bool Equals(Void* first, Void* second, IntPtr length)
  • public static Exception Error(object obj)
  • public static void Finalize(object obj)
  • public static int GetHashCode32<T>(Func<T, int, int> getter, int count, T arg, bool salted = true)
  • public static int GetHashCode32(Void* source, IntPtr length, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode32<THashFunction>(Void* source, IntPtr length, bool salted = true) where THashFunction : struct, IConsumer<int>, ISupplier<int>
  • public static int GetHashCode32(Void* source, IntPtr length, bool salted = true)
  • public static long GetHashCode64<T>(Func<T, int, long> getter, int count, T arg, bool salted = true)
  • public static long GetHashCode64(Void* source, IntPtr length, long hash, Func<long, long, long> hashFunction, bool salted = true)
  • public static long GetHashCode64<THashFunction>(Void* source, IntPtr length, bool salted = true) where THashFunction : struct, IConsumer<long>, ISupplier<long>
  • public static long GetHashCode64(Void* source, IntPtr length, bool salted = true)
  • public static IntPtr GetLength(Array array)
  • public static TBase& modreq(System.Runtime.InteropServices.InAttribute) GetReadonlyRef<T, TBase>(this T[] array, IntPtr index) where T : TBase
  • public static bool Equals(Void* first, Void* second, UIntPtr length)
  • public static UIntPtr GetLength(this Array array)
  • public static bool HasFlag<T>(T value, T flag) where T : struct, Enum
  • public static void KeepAlive<T>(ref T location) where T : struct
  • public static void Reverse<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static T ShallowCopy<T>(T obj)
  • public static void Throw(object obj)
  • public static void ThrowIfNull<T>(ref T value)
• public static class Reference
• public struct Reference<TValue>
• public struct ReadOnlyValueReference<T> : IEquatable<ReadOnlyValueReference<T>>, IEqualityOperators<ReadOnlyValueReference<T>, ReadOnlyValueReference<T>, bool>, ISupplier<T>, IFunctional<Func<T>>
  • public bool IsEmpty { get; }
  • public T& modreq(System.Runtime.InteropServices.InAttribute) Value { get; }
  • public ReadOnlyValueReference(object owner, ref T fieldRef)
  • public ReadOnlyValueReference(T[] array, int index)
  • public ReadOnlyValueReference(ref T staticFieldRef)
  • public static bool op_Equality(ReadOnlyValueReference<T> x, ReadOnlyValueReference<T> y)
  • public static Func<T> op_Explicit(ReadOnlyValueReference<T> reference)
  • public static ReadOnlySpan<T> op_Implicit(ReadOnlyValueReference<T> reference)
  • public static bool op_Inequality(ReadOnlyValueReference<T> x, ReadOnlyValueReference<T> y)
  • public bool Equals(ReadOnlyValueReference<T> reference)
  • public T& modreq(System.Runtime.InteropServices.InAttribute) GetPinnableReference()
• public class SoftReferenceOptions
  • public double MemoryThreshold { get; set; }
• public struct ValueReference<T> : IEquatable<ValueReference<T>>, IEqualityOperators<ValueReference<T>, ValueReference<T>, bool>, ISupplier<T>, IFunctional<Func<T>>, IConsumer<T>, IFunctional<Action<T>>
  • public bool IsEmpty { get; }
  • public ref T Value { get; }
  • public ValueReference(object owner, ref T fieldRef)
  • public ValueReference(T[] array, int index)
  • public ValueReference(T value)
  • public ValueReference(ref T staticFieldRef)
  • public static bool op_Equality(ValueReference<T> x, ValueReference<T> y)
  • public static Action<T> op_Explicit(ValueReference<T> reference)
  • public static Func<T> op_Explicit(ValueReference<T> reference)
  • public static ReadOnlyValueReference<T> op_Implicit(ValueReference<T> reference)
  • public static Span<T> op_Implicit(ValueReference<T> reference)
  • public static bool op_Inequality(ValueReference<T> x, ValueReference<T> y)
  • public bool Equals(ValueReference<T> reference)
  • public ref T GetPinnableReference()

DotNext.Runtime.Caching

• public enum CacheEvictionPolicy
  • LFU = 1
  • LRU = 0
• public class ConcurrentCache<TKey, TValue> : IReadOnlyDictionary<TKey, TValue>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyCollection<KeyValuePair<TKey, TValue>>
  • public int Capacity { get; }
  • public int Count { get; }
  • public Action<TKey, TValue> Eviction { get; set; }
  • public bool ExecuteEvictionAsynchronously { get; set; }
  • public TValue this[TKey key] { get; set; }
  • public ConcurrentCache(int capacity, int concurrencyLevel, CacheEvictionPolicy evictionPolicy, IEqualityComparer<TKey> keyComparer = null)
  • public ConcurrentCache(int capacity, CacheEvictionPolicy evictionPolicy, IEqualityComparer<TKey> keyComparer = null)
  • public TValue AddOrUpdate(TKey key, TValue value, out bool added)
  • public void Clear()
  • public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
  • public TValue GetOrAdd(TKey key, TValue value, out bool added)
  • public int TakeSnapshot(Span<KeyValuePair<TKey, TValue>> buffer, bool descendingOrder = true)
  • public bool TryAdd(TKey key, TValue value)
  • public bool TryGetValue(TKey key, out TValue value)
  • public bool TryRemove(TKey key, out TValue value)
  • public bool TryRemove(KeyValuePair<TKey, TValue> pair)
  • public bool TryUpdate(TKey key, TValue newValue, TValue expectedValue)

DotNext.Runtime.CompilerServices

• public sealed class FunctionalInterfaceAttribute : Attribute
• public sealed class Shared<T> where T : struct
• public interface IFunctional<TDelegate> where TDelegate : Delegate
  • TDelegate ToDelegate()
• public struct Scope : IDisposable, IAsyncDisposable
  • public void Defer(Action callback)
  • public void Defer(Func<ValueTask> callback)
  • public void Dispose()
  • public ValueTask DisposeAsync()
  • public void RegisterForDispose(IDisposable disposable)
  • public void RegisterForDisposeAsync(IAsyncDisposable disposable)
• public struct SpawningAsyncTaskMethodBuilder
  • public Task Task { get; }
  • public SpawningAsyncTaskMethodBuilder()
  • public static SpawningAsyncTaskMethodBuilder Create()
  • public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
  • public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
  • public void SetException(Exception e)
  • public void SetResult()
  • public void SetStateMachine(IAsyncStateMachine stateMachine)
  • public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
• public struct SpawningAsyncTaskMethodBuilder<TResult>
  • public Task<TResult> Task { get; }
  • public SpawningAsyncTaskMethodBuilder()
  • public static SpawningAsyncTaskMethodBuilder<TResult> Create()
  • public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
  • public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
  • public void SetException(Exception e)
  • public void SetResult(TResult result)
  • public void SetStateMachine(IAsyncStateMachine stateMachine)
  • public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
• public struct SuspendedExceptionTaskAwaitable
  • public struct Awaiter : ICriticalNotifyCompletion, INotifyCompletion
  • public SuspendedExceptionTaskAwaitable ConfigureAwait(bool continueOnCapturedContext)
  • public Awaiter GetAwaiter()
• public struct SuspendedExceptionTaskAwaitable<TArg>
  • public struct Awaiter<TArg> : ICriticalNotifyCompletion, INotifyCompletion
  • public SuspendedExceptionTaskAwaitable<TArg> ConfigureAwait(bool continueOnCapturedContext)
  • public Awaiter<TArg> GetAwaiter()

DotNext.Text

• public struct Base64Decoder
• public struct Base64Encoder
• public static class InterpolatedString
  • public static MemoryOwner<char> Interpolate(MemoryAllocator<char> allocator, IFormatProvider provider, ref PoolingInterpolatedStringHandler handler)
  • public static MemoryOwner<char> Interpolate(MemoryAllocator<char> allocator, ref PoolingInterpolatedStringHandler handler)

DotNext.Text.Encodings.Web

• public static class FileUri
  • public static string CreateFromFileName(ReadOnlySpan<char> fileName, TextEncoderSettings settings = null)
  • public static int GetMaxEncodedLength(ReadOnlySpan<char> fileName, UrlEncoder encoder = null)
  • public static Uri GetUri(this FileSystemInfo fileInfo, TextEncoderSettings settings = null)
  • public static bool TryCreateFromFileName(ReadOnlySpan<char> fileName, UrlEncoder encoder, Span<char> output, out int charsWritten)

DotNext.Threading

• public static class AsyncDelegate
• public static class Atomic
  • public struct Boolean : IEquatable<bool>
  • public static double AccumulateAndGet<TAccumulator>(ref double value, double x, TAccumulator accumulator) where TAccumulator : ISupplier<double, double, double>
  • public static double AccumulateAndGet(ref double value, double x, Func<double, double, double> accumulator)
  • public static IntPtr AccumulateAndGet<TAccumulator>(ref IntPtr value, IntPtr x, TAccumulator accumulator) where TAccumulator : ISupplier<IntPtr, IntPtr, IntPtr>
  • public static IntPtr AccumulateAndGet(ref IntPtr value, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
  • public static int AccumulateAndGet<TAccumulator>(ref int value, int x, TAccumulator accumulator) where TAccumulator : ISupplier<int, int, int>
  • public static int AccumulateAndGet(ref int value, int x, Func<int, int, int> accumulator)
  • public static long AccumulateAndGet<TAccumulator>(ref long value, long x, TAccumulator accumulator) where TAccumulator : ISupplier<long, long, long>
  • public static long AccumulateAndGet(ref long value, long x, Func<long, long, long> accumulator)
  • public static float AccumulateAndGet<TAccumulator>(ref float value, float x, TAccumulator accumulator) where TAccumulator : ISupplier<float, float, float>
  • public static float AccumulateAndGet(ref float value, float x, Func<float, float, float> accumulator)
  • public static UIntPtr AccumulateAndGet<TAccumulator>(ref UIntPtr value, UIntPtr x, TAccumulator accumulator) where TAccumulator : ISupplier<UIntPtr, UIntPtr, UIntPtr>
  • public static UIntPtr AccumulateAndGet(ref UIntPtr value, UIntPtr x, Func<UIntPtr, UIntPtr, UIntPtr> accumulator)
  • public static uint AccumulateAndGet<TAccumulator>(ref uint value, uint x, TAccumulator accumulator) where TAccumulator : ISupplier<uint, uint, uint>
  • public static uint AccumulateAndGet(ref uint value, uint x, Func<uint, uint, uint> accumulator)
  • public static ulong AccumulateAndGet<TAccumulator>(ref ulong value, ulong x, TAccumulator accumulator) where TAccumulator : ISupplier<ulong, ulong, ulong>
  • public static ulong AccumulateAndGet(ref ulong value, ulong x, Func<ulong, ulong, ulong> accumulator)
  • public static double GetAndAccumulate<TAccumulator>(ref double value, double x, TAccumulator accumulator) where TAccumulator : ISupplier<double, double, double>
  • public static double GetAndAccumulate(ref double value, double x, Func<double, double, double> accumulator)
  • public static IntPtr GetAndAccumulate<TAccumulator>(ref IntPtr value, IntPtr x, TAccumulator accumulator) where TAccumulator : ISupplier<IntPtr, IntPtr, IntPtr>
  • public static IntPtr GetAndAccumulate(ref IntPtr value, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
  • public static int GetAndAccumulate<TAccumulator>(ref int value, int x, TAccumulator accumulator) where TAccumulator : ISupplier<int, int, int>
  • public static int GetAndAccumulate(ref int value, int x, Func<int, int, int> accumulator)
  • public static long GetAndAccumulate<TAccumulator>(ref long value, long x, TAccumulator accumulator) where TAccumulator : ISupplier<long, long, long>
  • public static long GetAndAccumulate(ref long value, long x, Func<long, long, long> accumulator)
  • public static float GetAndAccumulate<TAccumulator>(ref float value, float x, TAccumulator accumulator) where TAccumulator : ISupplier<float, float, float>
  • public static float GetAndAccumulate(ref float value, float x, Func<float, float, float> accumulator)
  • public static UIntPtr GetAndAccumulate<TAccumulator>(ref UIntPtr value, UIntPtr x, TAccumulator accumulator) where TAccumulator : ISupplier<UIntPtr, UIntPtr, UIntPtr>
  • public static UIntPtr GetAndAccumulate(ref UIntPtr value, UIntPtr x, Func<UIntPtr, UIntPtr, UIntPtr> accumulator)
  • public static uint GetAndAccumulate<TAccumulator>(ref uint value, uint x, TAccumulator accumulator) where TAccumulator : ISupplier<uint, uint, uint>
  • public static uint GetAndAccumulate(ref uint value, uint x, Func<uint, uint, uint> accumulator)
  • public static ulong GetAndAccumulate<TAccumulator>(ref ulong value, ulong x, TAccumulator accumulator) where TAccumulator : ISupplier<ulong, ulong, ulong>
  • public static ulong GetAndAccumulate(ref ulong value, ulong x, Func<ulong, ulong, ulong> accumulator)
  • public static double GetAndUpdate<TUpdater>(ref double value, TUpdater updater) where TUpdater : ISupplier<double, double>
  • public static double GetAndUpdate(ref double value, Func<double, double> updater)
  • public static IntPtr GetAndUpdate<TUpdater>(ref IntPtr value, TUpdater updater) where TUpdater : ISupplier<IntPtr, IntPtr>
  • public static IntPtr GetAndUpdate(ref IntPtr value, Func<IntPtr, IntPtr> updater)
  • public static int GetAndUpdate<TUpdater>(ref int value, TUpdater updater) where TUpdater : ISupplier<int, int>
  • public static int GetAndUpdate(ref int value, Func<int, int> updater)
  • public static long GetAndUpdate<TUpdater>(ref long value, TUpdater updater) where TUpdater : ISupplier<long, long>
  • public static long GetAndUpdate(ref long value, Func<long, long> updater)
  • public static float GetAndUpdate<TUpdater>(ref float value, TUpdater updater) where TUpdater : ISupplier<float, float>
  • public static float GetAndUpdate(ref float value, Func<float, float> updater)
  • public static UIntPtr GetAndUpdate<TUpdater>(ref UIntPtr value, TUpdater updater) where TUpdater : ISupplier<UIntPtr, UIntPtr>
  • public static UIntPtr GetAndUpdate(ref UIntPtr value, Func<UIntPtr, UIntPtr> updater)
  • public static uint GetAndUpdate<TUpdater>(ref uint value, TUpdater updater) where TUpdater : ISupplier<uint, uint>
  • public static uint GetAndUpdate(ref uint value, Func<uint, uint> updater)
  • public static ulong GetAndUpdate<TUpdater>(ref ulong value, TUpdater updater) where TUpdater : ISupplier<ulong, ulong>
  • public static ulong GetAndUpdate(ref ulong value, Func<ulong, ulong> updater)
  • public static bool IsAtomic<T>()
  • public static double UpdateAndGet<TUpdater>(ref double value, TUpdater updater) where TUpdater : ISupplier<double, double>
  • public static double UpdateAndGet(ref double value, Func<double, double> updater)
  • public static IntPtr UpdateAndGet<TUpdater>(ref IntPtr value, TUpdater updater) where TUpdater : ISupplier<IntPtr, IntPtr>
  • public static IntPtr UpdateAndGet(ref IntPtr value, Func<IntPtr, IntPtr> updater)
  • public static int UpdateAndGet<TUpdater>(ref int value, TUpdater updater) where TUpdater : ISupplier<int, int>
  • public static int UpdateAndGet(ref int value, Func<int, int> updater)
  • public static long UpdateAndGet<TUpdater>(ref long value, TUpdater updater) where TUpdater : ISupplier<long, long>
  • public static long UpdateAndGet(ref long value, Func<long, long> updater)
  • public static float UpdateAndGet<TUpdater>(ref float value, TUpdater updater) where TUpdater : ISupplier<float, float>
  • public static float UpdateAndGet(ref float value, Func<float, float> updater)
  • public static UIntPtr UpdateAndGet<TUpdater>(ref UIntPtr value, TUpdater updater) where TUpdater : ISupplier<UIntPtr, UIntPtr>
  • public static UIntPtr UpdateAndGet(ref UIntPtr value, Func<UIntPtr, UIntPtr> updater)
  • public static uint UpdateAndGet<TUpdater>(ref uint value, TUpdater updater) where TUpdater : ISupplier<uint, uint>
  • public static uint UpdateAndGet(ref uint value, Func<uint, uint> updater)
  • public static ulong UpdateAndGet<TUpdater>(ref ulong value, TUpdater updater) where TUpdater : ISupplier<ulong, ulong>
  • public static ulong UpdateAndGet(ref ulong value, Func<ulong, ulong> updater)
• public struct AtomicBoolean : IEquatable<bool>
• public static class AtomicDouble
• public static class AtomicEnum
• public struct AtomicEnum<TEnum> : IEquatable<TEnum> where TEnum : struct, Enum
• public static class AtomicInt32
• public static class AtomicInt64
• public static class AtomicIntPtr
• public static class AtomicReference
• public static class AtomicSingle
• public static class AtomicUInt32
• public static class AtomicUInt64
• public class Epoch
  • public abstract class Discardable : IThreadPoolWorkItem
  • public struct RecycleBin : IThreadPoolWorkItem
  • public struct Scope
  • public Epoch()
  • public Scope Enter(bool drainGlobalCache, out RecycleBin bin)
  • public Scope Enter(bool? drainGlobalCache = false)
  • public void Enter(bool drainGlobalCache, out Scope scope)
  • public void UnsafeClear()
  • public Scope UnsafeEnter(bool drainGlobalCache = false)
• public interface IInterlockedOperations<T>
  • T CompareExchange(ref T location, T value, T comparand)
  • T VolatileRead(T& modreq(System.Runtime.InteropServices.InAttribute) location)
  • void VolatileWrite(ref T location, T value)
• public struct Lock : IDisposable, IEquatable<Lock>
  • public static bool TryEnterMonitor(object obj, TimeSpan timeout, CancellationToken token, bool throwOnCancellation = false)
• public struct Timeout
  • public const long InfiniteTicks = -10000
  • public const long MaxTimeoutParameterTicks = 21474836470000
  • public static Timeout Expired { get; }
  • public TimeSpan? RemainingTime { get; }
  • public Timeout(TimeSpan timeout, TimeProvider provider)
  • public Timeout(TimeSpan timeout, Timestamp startedAt)
  • public static void Validate(TimeSpan timeout, string parameterName = null)
  • public void ThrowIfExpired(TimeProvider provider)
  • public void ThrowIfExpired(TimeProvider provider, out TimeSpan remainingTime)
  • public bool TryGetRemainingTime(out TimeSpan remainingTime)
  • public bool TryGetRemainingTime(TimeProvider provider, out TimeSpan remainingTime)

DotNext.Threading.Tasks

• public static class CompletedTask<T, TConstant> where TConstant : Constant<T>
• public static class Continuation
• public static class Conversion
  • public static SuspendedExceptionTaskAwaitable SuspendException(this Task task, Predicate<Exception> filter = null)
  • public static SuspendedExceptionTaskAwaitable SuspendException(this ValueTask task, Predicate<Exception> filter = null)
  • public static SuspendedExceptionTaskAwaitable<TArg> SuspendException<TArg>(this Task task, TArg arg, Func<Exception, TArg, bool> filter)
  • public static SuspendedExceptionTaskAwaitable<TArg> SuspendException<TArg>(this ValueTask task, TArg arg, Func<Exception, TArg, bool> filter)
• public struct DynamicTaskAwaitable
  • public DynamicTaskAwaitable ConfigureAwait(ConfigureAwaitOptions options)
• public static class Synchronization
  • public static void Wait(this ref ValueTask task)
  • public static T Wait<T>(this ref ValueTask task)