DotNext by Roman Sakno

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

---

API Diff between 3.2.1 and 5.0.3

777 Additions 228 Removals

DotNext

• public static class BasicExtensions
• public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : struct
  • public static int GetHashCode(ref T value, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode(ref T value, int hash, method hashFunction, bool salted = true)
• public enum BoundType
  • Closed = 3
  • LeftClosed = 1
  • Open = 0
  • RightClosed = 2
• public abstract class CharComparer : IEqualityComparer<char>, IComparer<char>
• public static class Comparison
  • public static bool Between<T>(this T value, T left, T right, BoundType boundType = 0) where T : IComparable<T>
  • public static T Clamp<T>(this T value, T min, T max) where T : IComparable<T>
• public static class DelegateHelpers
  • public static Func<bool> Bind<T>(this Predicate<T> predicate, T obj)
  • public static Predicate<T> Unbind<T>(this Func<bool> func)
• public struct DelegatingConsumer<T> : IConsumer<T>
  • public static DelegatingConsumer<T> op_Implicit(Action<T> action)
• public struct DisclosedEndpoint<T> : IFiniteRangeEndpoint<T>, IRangeEndpoint<T> where T : IComparable<T>
• public abstract class Disposable : IDisposable
  • protected bool IsDisposing { get; }
  • protected bool IsDisposingOrDisposed { get; }
  • public static void Dispose(ReadOnlySpan<IDisposable> objects)
  • public static void Dispose(IDisposable[] objects)
  • protected ValueTask DisposeAsync()
  • protected ValueTask DisposeAsync(bool continueOnCapturedContext)
  • protected bool TryBeginDispose()
  • protected void ThrowIfDisposed()
  • protected bool TrySetDisposedException(TaskCompletionSource source)
• public struct EnclosedEndpoint<T> : IFiniteRangeEndpoint<T>, IRangeEndpoint<T> where T : IComparable<T>
• 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 TypeCode GetTypeCode<TEnum>() where TEnum : 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 bool IsOneOf<T>(this T value, T[] values) where T : struct, Enum
  • public static byte ToByte<T>(this T value) where T : struct, Enum
  • public static T ToEnum<T>(this long value) where T : struct, Enum
  • public static T ToEnum<T>(this int value) where T : struct, Enum
  • public static T ToEnum<T>(this short value) where T : struct, Enum
  • public static T ToEnum<T>(this byte value) where T : struct, Enum
  • public static T ToEnum<T>(this sbyte value) where T : struct, Enum
  • public static T ToEnum<T>(this ushort value) where T : struct, Enum
  • public static T ToEnum<T>(this uint value) where T : struct, Enum
  • public static T ToEnum<T>(this ulong value) where T : struct, Enum
  • public static short ToInt16<T>(this T value) where T : struct, Enum
  • public static int ToInt32<T>(this T value) where T : struct, Enum
  • public static long ToInt64<T>(this T value) where T : struct, Enum
  • public static sbyte ToSByte<T>(this T value) where T : struct, Enum
  • public static ushort ToUInt16<T>(this T value) where T : struct, Enum
  • public static uint ToUInt32<T>(this T value) where T : struct, Enum
  • public static ulong ToUInt64<T>(this T value) where T : struct, Enum
• public static class Func
  • public static Func<T, T> Identity<T>(this Action<T> action)
  • public static Func<object, bool> IsTypeOf<T>()
• public interface IFiniteRangeEndpoint<T> : IRangeEndpoint<T>
• public interface IOptionMonad<T> : ISupplier<object>, IFunctional<Func<object>>
• public interface IOptionMonad<T, TSelf> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>> where TSelf : struct, IOptionMonad<T, TSelf>
• public interface IRangeEndpoint<T>
• public interface IResettable
• public interface IResultMonad<T, TError> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>
• 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>
• public interface ISupplier<TResult>
  • ISupplier<TResult> NullOrDefault { get; }
• public static class ObjectExtensions
  • public static T As<T>(this T obj)
  • public static UserDataStorage GetUserData<T>(this T obj)
  • public static bool IsOneOf<T>(this T value, IEnumerable<T> values)
  • public static bool IsOneOf<T>(this T value, T[] values)
• public static class OneDimensionalArray
  • public static int BitwiseCompare<T>(this T[] first, T[] second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static bool BitwiseEquals<T>(this T[] first, T[] second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this T[] array, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this T[] array, int hash, Func<int, int, int> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this T[] array, int hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this T[] array, long hash, Func<long, long, long> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this T[] array, long hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this T[] array, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static T[] Concat<T>(this T[] left, T[] right, long startIndex)
  • public static void ForEach<T>(this T[] array, RefAction<T, long> action)
  • public static void ForEach<T, TArg>(this T[] array, method action, TArg arg)
  • public static T[] Insert<T>(this T[] array, T element, long index)
  • public static bool IsNullOrEmpty<T>(this T[] array)
  • public static T[] RemoveAll<T>(this T[] array, Predicate<T> match, out long count)
  • public static T[] RemoveAll<T>(this T[] array, method match, out long count)
  • public static T[] RemoveAll<T>(this T[] array, Predicate<T> match, Action<T> callback)
  • public static T[] RemoveAll<T>(this T[] array, method match, Action<T> callback)
  • public static T[] RemoveAt<T>(this T[] array, long index)
  • public static T[] RemoveFirst<T>(this T[] input, long count)
  • public static T[] RemoveLast<T>(this T[] input, long count)
  • public static bool SequenceEqual(this object[] first, object[] second, bool parallel = false)
  • public static T[] Slice<T>(this T[] input, long startIndex, long length)
  • public static ArraySegment<T> Slice<T>(this T[] input, Range range)
• public static class Optional
  • public static Optional<T> Create<T, TMonad>(TMonad value) where TMonad : struct, IOptionMonad<T>
  • public static Optional<T> Flatten<T>(this ref Optional optional)
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T, TException>(this ref Optional optional) where T : struct where TException : Exception
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(this ref Optional optional, Func<Exception> exceptionFactory) where T : struct
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(this ref Optional optional, method exceptionFactory) where T : struct
• public struct Optional<T> : IEquatable<Optional<T>>, IEquatable<T>, IStructuralEquatable, ISerializable
  • public T ValueOrDefault { get; }
  • public T& modreq(System.Runtime.InteropServices.InAttribute) ValueRef { get; }
  • public static bool IsValueDefined(T value)
  • public static T op_BitwiseOr(ref Optional optional, T defaultValue)
  • 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> Constant<T>(bool value)
  • public static Predicate<T> False<T>()
  • public static Predicate<object> IsTypeOf<T>()
  • 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 Result<T> FromException<T>(Exception e)
  • public static Result<T> FromValue<T>(T value)
  • public static T? OrNull<T, TError>(this ref Result result) where T : struct where TError : struct, Enum
• public struct Result<T> : ISerializable
  • 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 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 static class Span
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • 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>(this Span<T> span, int hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • 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>(this ReadOnlySpan<T> span, int hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • 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>(this Span<T> span, long hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • 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>(this ReadOnlySpan<T> span, long hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • 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 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> FirstOrNone<T>(this ReadOnlySpan<T> span, Predicate<T> filter)
  • public static int FromHex(this ReadOnlySpan<char> chars, Span<byte> output)
  • public static byte[] FromHex(this ReadOnlySpan<char> chars)
  • public static void Initialize<T>(this Span<T> span)
  • public static void Move<T>(this Span<T> span, Range range, Index destinationIndex)
  • public static void Sort<T>(this Span<T> span, IComparer<T> comparison = null)
  • public static void Sort<T>(this Span<T> span, Comparison<T> comparison)
  • 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 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 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 static class TupleExtensions
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
• public sealed class UndefinedResultException<TError> : Exception where TError : struct, Enum
• public struct UserDataSlot<TValue> : IEquatable<UserDataSlot<TValue>>
  • public bool IsAllocated { get; }
  • public UserDataSlot()
  • public static UserDataSlot<TValue> Allocate()
• public struct UserDataStorage
  • public bool IsValid { get; }
  • public IReadOnlyDictionary<string, object> Capture()
• public struct ValueSupplier<T> : ISupplier<T>, IFunctional<Func<T>>
• public static class ValueTypeExtensions
  • public static IntPtr Add(this IntPtr x, IntPtr y)
  • public static UIntPtr Add(this UIntPtr x, UIntPtr y)
  • public static IntPtr AddChecked(this IntPtr x, IntPtr y)
  • public static UIntPtr AddChecked(this UIntPtr x, UIntPtr y)
  • public static UIntPtr And(this UIntPtr x, UIntPtr y)
  • public static IntPtr And(this IntPtr x, IntPtr y)
  • public static IntPtr Decrement(this IntPtr value)
  • public static UIntPtr Decrement(this UIntPtr value)
  • public static IntPtr Divide(this IntPtr x, IntPtr y)
  • public static UIntPtr Divide(this UIntPtr x, UIntPtr y)
  • public static bool GreaterThan(this IntPtr value, IntPtr comparand)
  • public static bool GreaterThan(this UIntPtr value, UIntPtr comparand)
  • public static bool GreaterThanOrEqual(this IntPtr value, IntPtr comparand)
  • public static bool GreaterThanOrEqual(this UIntPtr value, UIntPtr comparand)
  • public static IntPtr Increment(this IntPtr value)
  • public static UIntPtr Increment(this UIntPtr value)
  • public static bool IsOneOf<T>(this T value, IEnumerable<T> values) where T : struct, IEquatable<T>
  • public static bool IsOneOf<T>(this T value, T[] values) where T : struct, IEquatable<T>
  • public static IntPtr LeftShift(this IntPtr value, int bits)
  • public static UIntPtr LeftShift(this UIntPtr value, int bits)
  • public static bool LessThan(this IntPtr value, IntPtr comparand)
  • public static bool LessThan(this UIntPtr value, UIntPtr comparand)
  • public static bool LessThanOrEqual(this IntPtr value, IntPtr comparand)
  • public static bool LessThanOrEqual(this UIntPtr value, UIntPtr comparand)
  • public static IntPtr Multiply(this IntPtr x, IntPtr y)
  • public static UIntPtr Multiply(this UIntPtr x, UIntPtr y)
  • public static IntPtr MultiplyChecked(this IntPtr x, IntPtr y)
  • public static UIntPtr MultiplyChecked(this UIntPtr x, UIntPtr y)
  • public static IntPtr Negate(this IntPtr value)
  • public static IntPtr OnesComplement(this IntPtr value)
  • public static UIntPtr OnesComplement(this UIntPtr value)
  • public static IntPtr Or(this IntPtr x, IntPtr y)
  • public static UIntPtr Or(this UIntPtr x, UIntPtr y)
  • public static IntPtr Remainder(this IntPtr x, IntPtr y)
  • public static UIntPtr Remainder(this UIntPtr x, UIntPtr y)
  • public static IntPtr RightShift(this IntPtr value, int bits)
  • public static UIntPtr RightShift(this UIntPtr value, int bits)
  • public static IntPtr Subtract(this IntPtr x, IntPtr y)
  • public static UIntPtr Subtract(this UIntPtr x, UIntPtr y)
  • public static IntPtr SubtractChecked(this IntPtr x, IntPtr y)
  • public static UIntPtr SubtractChecked(this UIntPtr x, UIntPtr y)
  • public static bool ToBoolean(this int value)
  • public static byte ToByte(this bool value)
  • public static int ToInt32(this bool value)
  • public static IntPtr ToIntPtr(this UIntPtr value)
  • public static IntPtr ToIntPtrChecked(this UIntPtr value)
  • public static UIntPtr ToUIntPtr(this IntPtr value)
  • public static UIntPtr ToUIntPtrChecked(this IntPtr value)
  • public static int Truncate(this long value)
  • public static bool TryGetValue<T>(this T? nullable, out T value) where T : struct
  • public static IntPtr Xor(this IntPtr x, IntPtr y)
  • public static UIntPtr Xor(this UIntPtr x, UIntPtr y)

DotNext.Buffers

• public static class BufferHelpers
  • public static string BuildString(this ArrayBufferWriter<char> writer)
  • 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 ref T GetReference<T>(ref MemoryOwner owner)
  • public static T Read<T>(this ref SpanReader reader) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static double ReadDouble(this ref SpanReader reader, bool isLittleEndian)
  • public static short ReadInt16(this ref SpanReader reader, bool isLittleEndian)
  • public static int ReadInt32(this ref SpanReader reader, bool isLittleEndian)
  • public static long ReadInt64(this ref SpanReader reader, bool isLittleEndian)
  • public static float ReadSingle(this ref SpanReader reader, bool isLittleEndian)
  • public static ushort ReadUInt16(this ref SpanReader reader, bool isLittleEndian)
  • public static uint ReadUInt32(this ref SpanReader reader, bool isLittleEndian)
  • public static ulong ReadUInt64(this ref SpanReader reader, bool isLittleEndian)
  • public static void ReleaseAll<T>(this ref MemoryOwner owner) where T : IDisposable
  • public static void Resize<T>(this ref MemoryOwner owner, int newLength, bool exactSize = true, MemoryAllocator<T> allocator = null)
  • public static ReadOnlySequence<T> ToReadOnlySequence<T>(this IEnumerable<ReadOnlyMemory<T>> chunks)
  • public static bool TryRead<T>(this ref SpanReader reader, out T result) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static bool TryWrite<T>(this ref SpanWriter writer, ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Write(this ref BufferWriterSlim writer, StringBuilder input)
  • public static void Write<T>(this IBufferWriter<T> writer, T value)
  • public static void Write<T>(this IBufferWriter<T> writer, ref ReadOnlySequence value)
  • public static void Write(this IBufferWriter<char> writer, StringBuilder input)
  • public static void Write<T>(this ref SpanWriter writer, ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Write(this ref SpanWriter writer, StringBuilder input)
  • public static void WriteDouble(this ref BufferWriterSlim builder, double value, bool isLittleEndian)
  • public static void WriteDouble(this ref SpanWriter writer, double value, bool isLittleEndian)
  • public static void WriteInt16(this ref BufferWriterSlim builder, short value, bool isLittleEndian)
  • public static void WriteInt16(this ref SpanWriter writer, short value, bool isLittleEndian)
  • public static void WriteInt32(this ref BufferWriterSlim builder, int value, bool isLittleEndian)
  • public static void WriteInt32(this ref SpanWriter writer, int value, bool isLittleEndian)
  • public static void WriteInt64(this ref BufferWriterSlim builder, long value, bool isLittleEndian)
  • public static void WriteInt64(this ref SpanWriter writer, long value, bool isLittleEndian)
  • public static void WriteSingle(this ref BufferWriterSlim builder, float value, bool isLittleEndian)
  • public static void WriteSingle(this ref SpanWriter writer, float value, bool isLittleEndian)
  • public static void WriteUInt16(this ref BufferWriterSlim builder, ushort value, bool isLittleEndian)
  • public static void WriteUInt16(this ref SpanWriter writer, ushort value, bool isLittleEndian)
  • public static void WriteUInt32(this ref BufferWriterSlim builder, uint value, bool isLittleEndian)
  • public static void WriteUInt32(this ref SpanWriter writer, uint value, bool isLittleEndian)
  • public static void WriteUInt64(this ref BufferWriterSlim builder, ulong value, bool isLittleEndian)
  • public static void WriteUInt64(this ref SpanWriter writer, ulong value, bool isLittleEndian)
• public abstract class BufferWriter<T> : Disposable, IBufferWriter<T>, ISupplier<ReadOnlyMemory<T>>, IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IGrowableBuffer<T>, IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IDisposable
  • public void Rewind(int count)
• public struct BufferWriterInterpolatedStringHandler
• public struct BufferWriterSlim<T>
  • public ref T Add()
  • public void Rewind(int count)
  • public bool TryPeek(out T item)
  • public bool TryPop(out T item)
  • public bool TryPop(Span<T> output)
• public struct BufferWriterSlimInterpolatedStringHandler
• public static class ByteBuffer
• public static class CharBuffer
• public static class Memory
• public static class MemoryAllocator
  • public static MemoryAllocator<T> CreateArrayAllocator<T>()
  • public static MemoryOwner<T> Invoke<T>(this MemoryAllocator<T> allocator, int length, bool exactSize)
  • 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 struct MemoryOwner<T> : IMemoryOwner<T>, IDisposable, ISupplier<Memory<T>>
  • public ref T this[IntPtr index] { get; }
  • public Span<T> Span { get; }
  • public static MemoryOwner<T> Create<TArg>(method provider, int length, TArg arg, bool exactSize = true)
  • public bool TryGetArray(out ArraySegment segment)
• public sealed class PoolingArrayBufferWriter<T> : BufferWriter<T>, ISupplier<ArraySegment<T>>, IFunctional<Func<ArraySegment<T>>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
• public sealed class PoolingBufferWriter<T> : BufferWriter<T>, IMemoryOwner<T>, IDisposable
• public struct PoolingInterpolatedStringHandler : IGrowableBuffer<char>, IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IDisposable, IResettable
• public static class ReadOnlySequencePartitioner
• public struct MemoryRental<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 MemoryRental(Span<T> span)
  • public MemoryRental(Span<T> span, int length)
  • public MemoryRental(MemoryPool<T> pool, int minBufferSize, bool exactSize = true)
  • public MemoryRental(MemoryPool<T> pool)
  • public MemoryRental(int minBufferSize, bool exactSize = true)
  • public static MemoryRental<T> op_Implicit(Span<T> span)
  • public void Dispose()
  • public ref T GetPinnableReference()
• public static class MemoryTemplate
  • public static void Render(this ref MemoryTemplate template, StringBuilder output, string[] replacement)
  • public static string Render(this ref MemoryTemplate template, string[] replacement)
  • public static void Render(this ref MemoryTemplate template, TextWriter output, string[] replacement)
• public struct MemoryTemplate<T> where T : IEquatable<T>
  • public ReadOnlyMemory<T> Value { get; }
  • public MemoryTemplate(ReadOnlyMemory<T> template, ReadOnlySpan<T> placeholder)
  • public void Render<TConsumer>(TConsumer consumer) where TConsumer : IReadOnlySpanConsumer<T>, IConsumer<int>
  • public void Render<TWriter>(TWriter output, Action<int, TWriter> rewriter) where TWriter : IBufferWriter<T>
  • public void Render<TArg>(TArg arg, Action<int, TArg> rewriter, ReadOnlySpanAction<T, TArg> output)
• public sealed class PooledArrayBufferWriter<T> : BufferWriter<T>, ISupplier<ArraySegment<T>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
  • public ref T this[int index] { get; }
  • public ref T this[long index] { get; }
  • public ArraySegment<T> WrittenArray { get; }
  • public PooledArrayBufferWriter(ArrayPool<T> pool, int initialCapacity)
  • public PooledArrayBufferWriter(ArrayPool<T> pool)
  • public PooledArrayBufferWriter()
  • public PooledArrayBufferWriter(int initialCapacity)
  • 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 PooledBufferWriter<T> : BufferWriter<T>, IMemoryOwner<T>, IDisposable
  • public PooledBufferWriter(MemoryAllocator<T> allocator, int initialCapacity)
  • public PooledBufferWriter(MemoryAllocator<T> allocator = null)
• public struct SpanOwner<T>
• public struct SpanReader<T>
  • public T& modreq(System.Runtime.InteropServices.InAttribute) Read()
  • public T Read()
• public struct SpanWriter<T>
  • public ref T Add()
  • public void Write<TArg>(method action, TArg arg, int count)
  • public void Write<TArg>(method action, TArg arg, int count)
• public class SparseBufferWriter<T> : Disposable, IEnumerable<ReadOnlyMemory<T>>, IEnumerable, IGrowableBuffer<T>, IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IDisposable, ISupplier<ReadOnlySequence<T>>, IBufferWriter<T>
  • public SequencePosition End { get; }
  • public SequencePosition Start { get; }
  • public void Add(T item)
  • 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 struct Blittable<T> : IBinaryFormattable<Blittable<T>> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public interface IBinaryFormattable<TSelf> where TSelf : IBinaryFormattable<TSelf>

DotNext.Buffers.Text

• public struct Base64Decoder : IResettable
• public struct Base64Encoder : IResettable
• public static class Hex

DotNext.Collections.Generic

• public static class AsyncEnumerable
• 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 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 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 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 string ToString<T>(this IEnumerable<T> collection, string delimiter, string ifEmpty = "")
• public static class Enumerator
• public static class Set
• public static class Sequence
  • public struct AsyncGenerator<T> : IAsyncEnumerable<T>
  • public struct ConsumingEnumerable<T> : IEnumerable<T>, IEnumerable
  • public struct Generator<T>
  • public struct LimitedEnumerator<T> : IEnumerator<T>, IEnumerator, IDisposable
  • public static IEnumerable<T> Append<T>(this IEnumerable<T> collection, T[] items)
  • public static bool ElementAt<T>(this IEnumerable<T> collection, int index, out T element)
  • public static ValueTask<Optional<T>> ElementAtAsync<T>(this IAsyncEnumerable<T> collection, int index, CancellationToken token = default)
  • public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq)
  • public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq, Predicate<T> filter)
  • public static ValueTask<Optional<T>> FirstOrEmptyAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default)
  • public static ValueTask<Optional<T>> FirstOrEmptyAsync<T>(this IAsyncEnumerable<T> seq, Predicate<T> filter, CancellationToken token = default)
  • public static T? FirstOrNull<T>(this IEnumerable<T> seq) where T : struct
  • public static ValueTask<T?> FirstOrNullAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default) where T : struct
  • public static void ForEach<T>(this IEnumerable<T> collection, Action<T> action)
  • 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 ForEachAsync<T>(this IEnumerable<T> collection, Func<T, CancellationToken, ValueTask> action, CancellationToken token = default)
  • public static IAsyncEnumerator<T> GetAsyncEnumerator<T>(this IEnumerable<T> enumerable, CancellationToken token = default)
  • public static ConsumingEnumerable<T> GetConsumer<T>(this IProducerConsumerCollection<T> collection)
  • public static LimitedEnumerator<T> Limit<T>(this IEnumerator<T> enumerator, int count, bool leaveOpen = false)
  • public static IEnumerable<T> Prepend<T>(this IEnumerable<T> collection, T[] items)
  • public static int SequenceHashCode(this IEnumerable<object> sequence, bool salted = true)
  • public static IEnumerable<T> Singleton<T>(T item)
  • 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 ValueTask<bool> SkipAsync<T>(this IAsyncEnumerator<T> enumerator, int count)
  • public static IAsyncEnumerable<T> SkipNulls<T>(this IAsyncEnumerable<T> collection)
  • public static IEnumerable<T> SkipNulls<T>(this IEnumerable<T> collection)
  • public static Task<T[]> ToArrayAsync<T>(this IAsyncEnumerable<T> collection, int initialCapacity = 10, MemoryAllocator<T> allocator = null, CancellationToken token = default)
  • public static IAsyncEnumerable<T> ToAsyncEnumerable<T>(this IEnumerable<T> enumerable)
  • public static AsyncGenerator<T> ToAsyncEnumerable<T>(this Func<CancellationToken, ValueTask<Optional<T>>> generator)
  • public static Generator<T> ToEnumerable<T>(this Func<Optional<T>> generator)
  • public static IEnumerator<T> ToEnumerator<T>(ReadOnlyMemory<T> memory)
  • public static string ToString<T>(this IEnumerable<T> collection, string delimiter, string ifEmpty = "")

DotNext.Collections.Specialized

• public class ConcurrentTypeMap : ITypeMap, IReadOnlyTypeMap
• public class ConcurrentTypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>
• public static class InvocationList
• public struct InvocationList<TDelegate> : IReadOnlyList<TDelegate>, IEnumerable<TDelegate>, IEnumerable, IReadOnlyCollection<TDelegate> where TDelegate : MulticastDelegate
• public interface IReadOnlyTypeMap
• public interface IReadOnlyTypeMap<TValue>
• public interface ITypeMap : IReadOnlyTypeMap
• public interface ITypeMap<TValue> : IReadOnlyTypeMap<TValue>
• public struct SingletonList<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IList<T>, ICollection<T>, ITuple, IReadOnlySet<T>
• public class TypeMap : ITypeMap, IReadOnlyTypeMap
• public class TypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>

DotNext.ComponentModel.DataAnnotations

• public sealed class OptionalStringLengthAttribute : StringLengthAttribute
• public sealed class RequiredAttribute<T> : RequiredAttribute

DotNext.Diagnostics

• public struct Timestamp : IEquatable<Timestamp>, IComparable<Timestamp>
  • public static Timestamp Current { get; }
  • public double ElapsedMilliseconds { get; }
  • public long ElapsedTicks { get; }
  • public bool IsEmpty { get; }
  • public bool IsFuture { get; }
  • public bool IsPast { get; }
  • public Timestamp()
  • public Timestamp(TimeSpan ts)
  • public static Timestamp CompareExchange(ref Timestamp location, Timestamp value, Timestamp comparand)
  • public static Timestamp op_Addition(Timestamp x, TimeSpan y)
  • 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 Timestamp op_Subtraction(Timestamp x, TimeSpan y)
  • public static void Refresh(ref Timestamp location)
  • public double ElapsedSince(Timestamp past)

DotNext.Generic

• public abstract class BooleanConst : Constant<bool>
  • public sealed class False : BooleanConst
  • public sealed class True : BooleanConst
• public abstract class Constant<T> : ISupplier<T>
  • public T Value { get; }
  • protected Constant(T constVal)
  • public static T op_Implicit(Constant<T> const)
• public sealed class DefaultConst<T> : Constant<T>
  • public DefaultConst()
• public abstract class Int32Const : Constant<int>
  • public sealed class Max : Int32Const
  • public sealed class Min : Int32Const
  • public sealed class Zero : Int32Const
  • protected Int32Const(int value)
• public abstract class Int64Const : Constant<long>
  • public sealed class Max : Int64Const
  • public sealed class Min : Int64Const
  • public sealed class Zero : Int64Const
  • protected Int64Const(long value)
• public abstract class StringConst : Constant<string>
  • public sealed class Empty : StringConst
  • public sealed class Null : StringConst
  • protected StringConst(string value)

DotNext.IO

• public struct StreamConsumer : IReadOnlySpanConsumer<byte>, ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>, IEquatable<StreamConsumer>, IFlushable
  • public void Deconstruct(out Stream output)
• public static class StreamSource
  • 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>, IFlushable
  • 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 sealed class FNV1a128 : FNV1a<Int128, FNV1aParameters>
• public sealed class FNV1a32 : FNV1a<int, FNV1aParameters>
• public sealed class FNV1a64 : FNV1a<long, FNV1aParameters>
• public struct FNV1aParameters : IFNV1aParameters<int>, IFNV1aParameters<long>, IFNV1aParameters<Int128>
• public interface IFNV1aParameters<THash> where THash : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)

DotNext.Net.Http

• public sealed class HttpEndPoint : DnsEndPoint, ISupplier<UriBuilder>, IFunctional<Func<UriBuilder>>, IEquatable<HttpEndPoint>, IEqualityOperators<HttpEndPoint, HttpEndPoint, bool>

DotNext.Numerics

• public static class Number

DotNext.Patterns

• public interface IBuildable<TSelf, TBuilder> where TSelf : IBuildable<TSelf, TBuilder> where TBuilder : ISupplier<TSelf>, IResettable
• public interface ISingleton<TSelf> where TSelf : ISingleton<TSelf>

DotNext.Reflection

• public static class PropertyExtensions
• public static class TaskType
  • public static Func<Task, bool> IsCompletedSuccessfullyGetter { get; }
  • public static Func<bool> GetIsCompletedGetter(this Task task)
  • public static Func<Task<T>, T> GetResultGetter<T>()
• public static class TypeExtensions
  • public static object GetDefaultValue(this Type type)

DotNext.Runtime

• public abstract class BoxedValue<T> where T : struct
• public struct GCLatencyModeScope : IDisposable
• public abstract class GCNotification
• public struct Box<T> : IEquatable<Box<T>> where T : struct
  • public bool IsEmpty { get; }
  • public ref T Value { get; }
  • public Box(object boxed)
  • public Box(T value)
  • public static bool op_Equality(Box<T> x, Box<T> y)
  • public static T op_Explicit(Box<T> box)
  • public static bool op_Inequality(Box<T> x, Box<T> y)
  • public bool Equals(Box<T> other)
  • public ref T GetPinnableReference()
• public static class Intrinsics
  • public static int AlignOf<T>()
  • public static bool AreCompatible<T1, T2>()
  • public static bool AreSame<T>(ref T first, ref T second)
  • 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 int Compare(Void* first, Void* second, UIntPtr length)
  • public static void ClearBits(Void* address, long length)
  • public static int Compare(Void* first, Void* second, long length)
  • public static void Copy<T>(ref T source, out T destination, UIntPtr count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Copy<T>(ref T source, out T destination, long count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static bool Equals(Void* first, Void* second, UIntPtr length)
  • public static UIntPtr GetLength(this Array array)
  • public static bool HasFinalizer(object obj)
  • public static T DefaultOf<T>()
  • public static bool Equals(Void* first, Void* second, long length)
  • public static Exception Error(object obj)
  • public static T GetElement<T>(T[] array, IntPtr index)
  • public static T GetElement<T>(T[] array, UIntPtr index)
  • public static ref T GetElementReference<T>(T[] array, IntPtr index)
  • public static ref T GetElementReference<T>(T[] array, UIntPtr index)
  • public static int GetHashCode32<T>(Func<T, int, int> getter, int count, T arg, bool salted = true)
  • public static int GetHashCode32(Void* source, long length, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode32<THashFunction>(Void* source, long length, int hash, THashFunction hashFunction, bool salted = true) where THashFunction : struct, ISupplier<int, int, int>
  • public static int GetHashCode32(Void* source, long 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, long length, long hash, Func<long, long, long> hashFunction, bool salted = true)
  • public static long GetHashCode64<THashFunction>(Void* source, long length, long hash, THashFunction hashFunction, bool salted = true) where THashFunction : struct, ISupplier<long, long, long>
  • public static long GetHashCode64(Void* source, long 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 HasFlag<T>(T value, T flag) where T : struct, Enum
  • 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 int ToInt32(bool low, bool high)
• public sealed class SoftReference<T> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>
• public class SoftReferenceOptions
• public enum SoftReferenceState

DotNext.Runtime.Caching

• public enum CacheEvictionPolicy
• public class ConcurrentCache<TKey, TValue> : IReadOnlyDictionary<TKey, TValue>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyCollection<KeyValuePair<TKey, TValue>>

DotNext.Runtime.CompilerServices

• public interface IFunctional<TDelegate> where TDelegate : Delegate
• public struct Scope : IDisposable, IAsyncDisposable
• public struct SpawningAsyncTaskMethodBuilder
• public struct SpawningAsyncTaskMethodBuilder<TResult>
• public struct SuspendedExceptionTaskAwaitable
• public sealed class CallerMustBeSynchronizedAttribute : Attribute
  • public CallerMustBeSynchronizedAttribute()
• public sealed class FunctionalInterfaceAttribute : Attribute
  • public FunctionalInterfaceAttribute()
• public sealed class RuntimeFeaturesAttribute : Attribute
  • public bool DynamicCodeCompilation { get; set; }
  • public bool PrivateReflection { get; set; }
  • public bool RuntimeGenericInstantiation { get; set; }
  • public RuntimeFeaturesAttribute()

DotNext.Runtime.ExceptionServices

• public struct ExceptionAggregator : ISupplier<Exception>, IFunctional<Func<Exception>>

DotNext.Text

• public struct Base64Decoder
  • public bool NeedMoreData { get; }
  • public void Decode(ReadOnlySpan<char> chars, IBufferWriter<byte> output)
  • public void Decode(ref ReadOnlySequence chars, IBufferWriter<byte> output)
  • public void Decode<TConsumer>(ReadOnlySpan<char> chars, TConsumer output) where TConsumer : IReadOnlySpanConsumer<byte>
  • public void Decode<TArg>(ReadOnlySpan<char> chars, ReadOnlySpanAction<byte, TArg> callback, TArg arg)
  • public void Decode<TArg>(ReadOnlySpan<char> chars, method callback, TArg arg)
  • public void Decode(ReadOnlySpan<byte> utf8Chars, IBufferWriter<byte> output)
  • public void Decode(ref ReadOnlySequence utf8Chars, IBufferWriter<byte> output)
  • public void Decode<TConsumer>(ReadOnlySpan<byte> utf8Chars, TConsumer output) where TConsumer : IReadOnlySpanConsumer<byte>
  • public void Decode<TArg>(ReadOnlySpan<byte> utf8Chars, ReadOnlySpanAction<byte, TArg> output, TArg arg)
  • public void Decode<TArg>(ReadOnlySpan<byte> utf8Chars, method output, TArg arg)
  • public void Decode(ReadOnlySpan<byte> utf8Chars, Stream output)
• public static class InterpolatedString
• public struct StringBuilderConsumer : IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IEquatable<StringBuilderConsumer>

DotNext.Text.Json

• public sealed class OptionalConverter<T> : JsonConverter<Optional<T>>

DotNext.Threading

• public static class Atomic
• public static class AsyncDelegate
  • public static Task BeginInvoke(this Action<object> action, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null)
  • public static Task BeginInvoke(this Action<object, CancellationToken> action, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null, CancellationToken token = default)
  • public static Task<TResult> BeginInvoke<TResult>(this Func<object, TResult> function, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null)
  • public static Task<TResult> BeginInvoke<TResult>(this Func<object, CancellationToken, TResult> function, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null, CancellationToken token = default)
  • public static Task InvokeAsync<TDelegate>(this TDelegate delegate, Action<TDelegate> invoker, CancellationToken token = default) where TDelegate : MulticastDelegate
  • public static Task InvokeAsync<TEventArgs>(this EventHandler<TEventArgs> handler, object sender, TEventArgs args, CancellationToken token = default)
  • public static Task InvokeAsync(this EventHandler handler, object sender, EventArgs args, CancellationToken token = default)
  • public static Task InvokeAsync(this Action action, CancellationToken token = default)
  • public static Task InvokeAsync<T>(this Action<T> action, T arg, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2>(this Action<T1, T2> action, T1 arg1, T2 arg2, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3>(this Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4, T5, T6>(this Action<T1, T2, T3, T4, T5, T6> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7>(this Action<T1, T2, T3, T4, T5, T6, T7> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Action<T1, T2, T3, T4, T5, T6, T7, T8> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, CancellationToken token = default)
• public interface IInterlockedOperations<T>
• public struct AtomicBoolean : IEquatable<bool>, ISerializable
  • public bool Value { get; set; }
  • public AtomicBoolean(bool value)
  • public bool AccumulateAndGet(bool x, Func<bool, bool, bool> accumulator)
  • public bool AccumulateAndGet(bool x, method accumulator)
  • public bool CompareAndSet(bool expected, bool update)
  • public bool CompareExchange(bool update, bool expected)
  • public bool Equals(bool other)
  • public bool FalseToTrue()
  • public bool GetAndAccumulate(bool x, Func<bool, bool, bool> accumulator)
  • public bool GetAndAccumulate(bool x, method accumulator)
  • public bool GetAndNegate()
  • public bool GetAndSet(bool update)
  • public bool GetAndUpdate(Func<bool, bool> updater)
  • public bool GetAndUpdate(method updater)
  • public bool NegateAndGet()
  • public bool SetAndGet(bool update)
  • public bool TrueToFalse()
  • public bool UpdateAndGet(Func<bool, bool> updater)
  • public bool UpdateAndGet(method updater)
• public static class AtomicDouble
  • public static double AccumulateAndGet(this ref double value, double x, Func<double, double, double> accumulator)
  • public static double AccumulateAndGet(this ref double value, double x, method accumulator)
  • public static double AccumulateAndGet(this double[] array, long index, double x, Func<double, double, double> accumulator)
  • public static double AccumulateAndGet(this double[] array, long index, double x, method accumulator)
  • public static double Add(this ref double value, double operand)
  • public static double Add(this double[] array, long index, double operand)
  • public static bool CompareAndSet(this ref double value, double expected, double update)
  • public static bool CompareAndSet(this double[] array, long index, double expected, double update)
  • public static double CompareExchange(this double[] array, long index, double update, double comparand)
  • public static double DecrementAndGet(this ref double value)
  • public static double DecrementAndGet(this double[] array, long index)
  • public static double GetAndAccumulate(this ref double value, double x, Func<double, double, double> accumulator)
  • public static double GetAndAccumulate(this ref double value, double x, method accumulator)
  • public static double GetAndAccumulate(this double[] array, long index, double x, Func<double, double, double> accumulator)
  • public static double GetAndAccumulate(this double[] array, long index, double x, method accumulator)
  • public static double GetAndSet(this ref double value, double update)
  • public static double GetAndSet(this double[] array, long index, double update)
  • public static double GetAndUpdate(this ref double value, Func<double, double> updater)
  • public static double GetAndUpdate(this ref double value, method updater)
  • public static double GetAndUpdate(this double[] array, long index, Func<double, double> updater)
  • public static double GetAndUpdate(this double[] array, long index, method updater)
  • public static double IncrementAndGet(this ref double value)
  • public static double IncrementAndGet(this double[] array, long index)
  • public static double SetAndGet(this ref double value, double update)
  • public static double SetAndGet(this double[] array, long index, double update)
  • public static double UpdateAndGet(this ref double value, Func<double, double> updater)
  • public static double UpdateAndGet(this ref double value, method updater)
  • public static double UpdateAndGet(this double[] array, long index, Func<double, double> updater)
  • public static double UpdateAndGet(this double[] array, long index, method updater)
  • public static double VolatileRead(this ref double value)
  • public static double VolatileRead(this double[] array, long index)
  • public static void VolatileWrite(this ref double value, double newValue)
  • public static void VolatileWrite(this double[] array, long index, double value)
• public static class AtomicEnum
  • public static TEnum VolatileRead<TEnum>(this ref TEnum value) where TEnum : struct, Enum
  • public static void VolatileWrite<TEnum>(this ref TEnum value, TEnum newValue) where TEnum : struct, Enum
• public struct AtomicEnum<TEnum> : IEquatable<TEnum>, ISerializable where TEnum : struct, Enum
  • public TEnum Value { get; set; }
  • public AtomicEnum(TEnum value)
  • public TEnum AccumulateAndGet(TEnum x, Func<TEnum, TEnum, TEnum> accumulator)
  • public TEnum AccumulateAndGet(TEnum x, method accumulator)
  • public bool CompareAndSet(TEnum expected, TEnum update)
  • public TEnum CompareExchange(TEnum update, TEnum expected)
  • public bool Equals(TEnum other)
  • public TEnum GetAndAccumulate(TEnum x, Func<TEnum, TEnum, TEnum> accumulator)
  • public TEnum GetAndAccumulate(TEnum x, method accumulator)
  • public TEnum GetAndSet(TEnum update)
  • public TEnum GetAndUpdate(Func<TEnum, TEnum> updater)
  • public TEnum GetAndUpdate(method updater)
  • public TEnum SetAndGet(TEnum update)
  • public TEnum UpdateAndGet(Func<TEnum, TEnum> updater)
  • public TEnum UpdateAndGet(method updater)
• public static class AtomicInt32
  • public static int AccumulateAndGet(this ref int value, int x, Func<int, int, int> accumulator)
  • public static int AccumulateAndGet(this ref int value, int x, method accumulator)
  • public static int AccumulateAndGet(this int[] array, long index, int x, Func<int, int, int> accumulator)
  • public static int AccumulateAndGet(this int[] array, long index, int x, method accumulator)
  • public static int Add(this ref int value, int operand)
  • public static int Add(this int[] array, long index, int operand)
  • public static bool CompareAndSet(this ref int value, int expected, int update)
  • public static bool CompareAndSet(this int[] array, long index, int expected, int update)
  • public static int CompareExchange(this int[] array, long index, int update, int comparand)
  • public static int DecrementAndGet(this ref int value)
  • public static int DecrementAndGet(this int[] array, long index)
  • public static int GetAndAccumulate(this ref int value, int x, Func<int, int, int> accumulator)
  • public static int GetAndAccumulate(this ref int value, int x, method accumulator)
  • public static int GetAndAccumulate(this int[] array, long index, int x, Func<int, int, int> accumulator)
  • public static int GetAndAccumulate(this int[] array, long index, int x, method accumulator)
  • public static int GetAndSet(this ref int value, int update)
  • public static int GetAndSet(this int[] array, long index, int update)
  • public static int GetAndUpdate(this ref int value, Func<int, int> updater)
  • public static int GetAndUpdate(this ref int value, method updater)
  • public static int GetAndUpdate(this int[] array, long index, Func<int, int> updater)
  • public static int GetAndUpdate(this int[] array, long index, method updater)
  • public static int IncrementAndGet(this ref int value)
  • public static int IncrementAndGet(this int[] array, long index)
  • public static int SetAndGet(this ref int value, int update)
  • public static int SetAndGet(this int[] array, long index, int update)
  • public static int UpdateAndGet(this ref int value, Func<int, int> updater)
  • public static int UpdateAndGet(this ref int value, method updater)
  • public static int UpdateAndGet(this int[] array, long index, Func<int, int> updater)
  • public static int UpdateAndGet(this int[] array, long index, method updater)
  • public static int VolatileRead(this ref int value)
  • public static int VolatileRead(this int[] array, long index)
  • public static void VolatileWrite(this ref int value, int newValue)
  • public static void VolatileWrite(this int[] array, long index, int value)
• public static class AtomicInt64
  • public static long AccumulateAndGet(this ref long value, long x, Func<long, long, long> accumulator)
  • public static long AccumulateAndGet(this ref long value, long x, method accumulator)
  • public static long AccumulateAndGet(this long[] array, long index, long x, Func<long, long, long> accumulator)
  • public static long AccumulateAndGet(this long[] array, long index, long x, method accumulator)
  • public static long Add(this ref long value, long operand)
  • public static long Add(this long[] array, long index, long operand)
  • public static bool CompareAndSet(this ref long value, long expected, long update)
  • public static bool CompareAndSet(this long[] array, long index, long expected, long update)
  • public static long CompareExchange(this long[] array, long index, long update, long comparand)
  • public static long DecrementAndGet(this ref long value)
  • public static long DecrementAndGet(this long[] array, long index)
  • public static long GetAndAccumulate(this ref long value, long x, Func<long, long, long> accumulator)
  • public static long GetAndAccumulate(this ref long value, long x, method accumulator)
  • public static long GetAndAccumulate(this long[] array, long index, long x, Func<long, long, long> accumulator)
  • public static long GetAndAccumulate(this long[] array, long index, long x, method accumulator)
  • public static long GetAndSet(this ref long value, long update)
  • public static long GetAndSet(this long[] array, long index, long update)
  • public static long GetAndUpdate(this ref long value, Func<long, long> updater)
  • public static long GetAndUpdate(this ref long value, method updater)
  • public static long GetAndUpdate(this long[] array, long index, Func<long, long> updater)
  • public static long GetAndUpdate(this long[] array, long index, method updater)
  • public static long IncrementAndGet(this ref long value)
  • public static long IncrementAndGet(this long[] array, long index)
  • public static long SetAndGet(this ref long value, long update)
  • public static long SetAndGet(this long[] array, long index, long update)
  • public static long UpdateAndGet(this ref long value, Func<long, long> updater)
  • public static long UpdateAndGet(this ref long value, method updater)
  • public static long UpdateAndGet(this long[] array, long index, Func<long, long> updater)
  • public static long UpdateAndGet(this long[] array, long index, method updater)
  • public static long VolatileRead(this ref long value)
  • public static long VolatileRead(this long[] array, long index)
  • public static void VolatileWrite(this ref long value, long newValue)
  • public static void VolatileWrite(this long[] array, long index, long value)
• public static class AtomicIntPtr
  • public static IntPtr AccumulateAndGet(this ref IntPtr value, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
  • public static IntPtr AccumulateAndGet(this ref IntPtr value, IntPtr x, method accumulator)
  • public static IntPtr AccumulateAndGet(this IntPtr[] array, long index, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
  • public static IntPtr AccumulateAndGet(this IntPtr[] array, long index, IntPtr x, method accumulator)
  • public static IntPtr Add(this ref IntPtr value, IntPtr operand)
  • public static bool CompareAndSet(this ref IntPtr value, IntPtr expected, IntPtr update)
  • public static bool CompareAndSet(this IntPtr[] array, long index, IntPtr expected, IntPtr update)
  • public static IntPtr CompareExchange(this IntPtr[] array, long index, IntPtr update, IntPtr comparand)
  • public static IntPtr DecrementAndGet(this ref IntPtr value)
  • public static IntPtr DecrementAndGet(this IntPtr[] array, long index)
  • public static IntPtr GetAndAccumulate(this ref IntPtr value, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
  • public static IntPtr GetAndAccumulate(this ref IntPtr value, IntPtr x, method accumulator)
  • public static IntPtr GetAndAccumulate(this IntPtr[] array, long index, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
  • public static IntPtr GetAndAccumulate(this IntPtr[] array, long index, IntPtr x, method accumulator)
  • public static IntPtr GetAndSet(this ref IntPtr value, IntPtr update)
  • public static IntPtr GetAndSet(this IntPtr[] array, long index, IntPtr update)
  • public static IntPtr GetAndUpdate(this ref IntPtr value, Func<IntPtr, IntPtr> updater)
  • public static IntPtr GetAndUpdate(this ref IntPtr value, method updater)
  • public static IntPtr GetAndUpdate(this IntPtr[] array, long index, Func<IntPtr, IntPtr> updater)
  • public static IntPtr GetAndUpdate(this IntPtr[] array, long index, method updater)
  • public static IntPtr IncrementAndGet(this ref IntPtr value)
  • public static IntPtr IncrementAndGet(this IntPtr[] array, long index)
  • public static IntPtr SetAndGet(this ref IntPtr value, IntPtr update)
  • public static IntPtr SetAndGet(this IntPtr[] array, long index, IntPtr update)
  • public static IntPtr UpdateAndGet(this ref IntPtr value, Func<IntPtr, IntPtr> updater)
  • public static IntPtr UpdateAndGet(this ref IntPtr value, method updater)
  • public static IntPtr UpdateAndGet(this IntPtr[] array, long index, Func<IntPtr, IntPtr> updater)
  • public static IntPtr UpdateAndGet(this IntPtr[] array, long index, method updater)
  • public static IntPtr VolatileRead(this ref IntPtr value)
  • public static IntPtr VolatileRead(this IntPtr[] array, long index)
  • public static void VolatileWrite(this ref IntPtr value, IntPtr newValue)
  • public static void VolatileWrite(this IntPtr[] array, long index, IntPtr value)
• public static class AtomicReference
  • public static T AccumulateAndGet<T>(ref T value, T x, Func<T, T, T> accumulator)
  • public static T AccumulateAndGet<T>(ref T value, T x, method accumulator)
  • public static T AccumulateAndGet<T>(this T[] array, long index, T x, Func<T, T, T> accumulator)
  • public static T AccumulateAndGet<T>(this T[] array, long index, T x, method accumulator)
  • public static bool CompareAndSet<T>(ref T value, T expected, T update)
  • public static bool CompareAndSet<T>(this T[] array, long index, T expected, T update)
  • public static T CompareExchange<T>(this T[] array, long index, T update, T comparand)
  • public static T GetAndAccumulate<T>(ref T value, T x, Func<T, T, T> accumulator)
  • public static T GetAndAccumulate<T>(ref T value, T x, method accumulator)
  • public static T GetAndAccumulate<T>(this T[] array, long index, T x, Func<T, T, T> accumulator)
  • public static T GetAndAccumulate<T>(this T[] array, long index, T x, method accumulator)
  • public static T GetAndSet<T>(this T[] array, long index, T update)
  • public static T GetAndUpdate<T>(ref T value, Func<T, T> updater)
  • public static T GetAndUpdate<T>(ref T value, method updater)
  • public static T GetAndUpdate<T>(this T[] array, long index, Func<T, T> updater)
  • public static T GetAndUpdate<T>(this T[] array, long index, method updater)
  • public static T SetAndGet<T>(this T[] array, long index, T update)
  • public static T UpdateAndGet<T>(ref T value, Func<T, T> updater)
  • public static T UpdateAndGet<T>(ref T value, method updater)
  • public static T UpdateAndGet<T>(this T[] array, long index, Func<T, T> updater)
  • public static T UpdateAndGet<T>(this T[] array, long index, method updater)
  • public static T VolatileRead<T>(this T[] array, long index)
  • public static void VolatileWrite<T>(this T[] array, long index, T element)
• public static class AtomicSingle
  • public static float AccumulateAndGet(this ref float value, float x, Func<float, float, float> accumulator)
  • public static float AccumulateAndGet(this ref float value, float x, method accumulator)
  • public static float AccumulateAndGet(this float[] array, long index, float x, Func<float, float, float> accumulator)
  • public static float AccumulateAndGet(this float[] array, long index, float x, method accumulator)
  • public static float Add(this ref float value, float operand)
  • public static float Add(this float[] array, long index, float operand)
  • public static bool CompareAndSet(this ref float value, float expected, float update)
  • public static bool CompareAndSet(this float[] array, long index, float expected, float update)
  • public static float CompareExchange(this float[] array, long index, float update, float comparand)
  • public static float DecrementAndGet(this ref float value)
  • public static float DecrementAndGet(this float[] array, long index)
  • public static float GetAndAccumulate(this ref float value, float x, Func<float, float, float> accumulator)
  • public static float GetAndAccumulate(this ref float value, float x, method accumulator)
  • public static float GetAndAccumulate(this float[] array, long index, float x, Func<float, float, float> accumulator)
  • public static float GetAndAccumulate(this float[] array, long index, float x, method accumulator)
  • public static float GetAndSet(this ref float value, float update)
  • public static float GetAndSet(this float[] array, long index, float update)
  • public static float GetAndUpdate(this ref float value, Func<float, float> updater)
  • public static float GetAndUpdate(this ref float value, method updater)
  • public static float GetAndUpdate(this float[] array, long index, Func<float, float> updater)
  • public static float GetAndUpdate(this float[] array, long index, method updater)
  • public static float IncrementAndGet(this ref float value)
  • public static float IncrementAndGet(this float[] array, long index)
  • public static float SetAndGet(this ref float value, float update)
  • public static float SetAndGet(this float[] array, long index, float update)
  • public static float UpdateAndGet(this ref float value, Func<float, float> updater)
  • public static float UpdateAndGet(this ref float value, method updater)
  • public static float UpdateAndGet(this float[] array, long index, Func<float, float> updater)
  • public static float UpdateAndGet(this float[] array, long index, method updater)
  • public static float VolatileRead(this ref float value)
  • public static float VolatileRead(this float[] array, long index)
  • public static void VolatileWrite(this ref float value, float newValue)
  • public static void VolatileWrite(this float[] array, long index, float value)
• public static class AtomicUInt32
  • public static uint AccumulateAndGet(this ref uint value, uint x, Func<uint, uint, uint> accumulator)
  • public static uint AccumulateAndGet(this ref uint value, uint x, method accumulator)
  • public static uint AccumulateAndGet(this uint[] array, long index, uint x, Func<uint, uint, uint> accumulator)
  • public static uint AccumulateAndGet(this uint[] array, long index, uint x, method accumulator)
  • public static uint Add(this ref uint value, uint operand)
  • public static uint Add(this uint[] array, long index, uint operand)
  • public static bool CompareAndSet(this ref uint value, uint expected, uint update)
  • public static bool CompareAndSet(this uint[] array, long index, uint expected, uint update)
  • public static uint CompareExchange(this uint[] array, long index, uint update, uint comparand)
  • public static uint DecrementAndGet(this ref uint value)
  • public static uint DecrementAndGet(this uint[] array, long index)
  • public static uint GetAndAccumulate(this ref uint value, uint x, Func<uint, uint, uint> accumulator)
  • public static uint GetAndAccumulate(this ref uint value, uint x, method accumulator)
  • public static uint GetAndAccumulate(this uint[] array, long index, uint x, Func<uint, uint, uint> accumulator)
  • public static uint GetAndAccumulate(this uint[] array, long index, uint x, method accumulator)
  • public static uint GetAndSet(this ref uint value, uint update)
  • public static uint GetAndSet(this uint[] array, long index, uint update)
  • public static uint GetAndUpdate(this ref uint value, Func<uint, uint> updater)
  • public static uint GetAndUpdate(this ref uint value, method updater)
  • public static uint GetAndUpdate(this uint[] array, long index, Func<uint, uint> updater)
  • public static uint GetAndUpdate(this uint[] array, long index, method updater)
  • public static uint IncrementAndGet(this ref uint value)
  • public static uint IncrementAndGet(this uint[] array, long index)
  • public static uint SetAndGet(this ref uint value, uint update)
  • public static uint SetAndGet(this uint[] array, long index, uint update)
  • public static uint UpdateAndGet(this ref uint value, Func<uint, uint> updater)
  • public static uint UpdateAndGet(this ref uint value, method updater)
  • public static uint UpdateAndGet(this uint[] array, long index, Func<uint, uint> updater)
  • public static uint UpdateAndGet(this uint[] array, long index, method updater)
  • public static uint VolatileRead(this ref uint value)
  • public static uint VolatileRead(this uint[] array, long index)
  • public static void VolatileWrite(this ref uint value, uint newValue)
  • public static void VolatileWrite(this uint[] array, long index, uint value)
• public static class AtomicUInt64
  • public static ulong AccumulateAndGet(this ref ulong value, ulong x, Func<ulong, ulong, ulong> accumulator)
  • public static ulong AccumulateAndGet(this ref ulong value, ulong x, method accumulator)
  • public static ulong AccumulateAndGet(this ulong[] array, long index, ulong x, Func<ulong, ulong, ulong> accumulator)
  • public static ulong AccumulateAndGet(this ulong[] array, long index, ulong x, method accumulator)
  • public static ulong Add(this ref ulong value, ulong operand)
  • public static ulong Add(this ulong[] array, long index, ulong operand)
  • public static bool CompareAndSet(this ref ulong value, ulong expected, ulong update)
  • public static bool CompareAndSet(this ulong[] array, long index, ulong expected, ulong update)
  • public static ulong CompareExchange(this ulong[] array, long index, ulong update, ulong comparand)
  • public static ulong DecrementAndGet(this ref ulong value)
  • public static ulong DecrementAndGet(this ulong[] array, long index)
  • public static ulong GetAndAccumulate(this ref ulong value, ulong x, Func<ulong, ulong, ulong> accumulator)
  • public static ulong GetAndAccumulate(this ref ulong value, ulong x, method accumulator)
  • public static ulong GetAndAccumulate(this ulong[] array, long index, ulong x, Func<ulong, ulong, ulong> accumulator)
  • public static ulong GetAndAccumulate(this ulong[] array, long index, ulong x, method accumulator)
  • public static ulong GetAndSet(this ref ulong value, ulong update)
  • public static ulong GetAndSet(this ulong[] array, long index, ulong update)
  • public static ulong GetAndUpdate(this ref ulong value, Func<ulong, ulong> updater)
  • public static ulong GetAndUpdate(this ref ulong value, method updater)
  • public static ulong GetAndUpdate(this ulong[] array, long index, Func<ulong, ulong> updater)
  • public static ulong GetAndUpdate(this ulong[] array, long index, method updater)
  • public static ulong IncrementAndGet(this ref ulong value)
  • public static ulong IncrementAndGet(this ulong[] array, long index)
  • public static ulong SetAndGet(this ref ulong value, ulong update)
  • public static ulong SetAndGet(this ulong[] array, long index, ulong update)
  • public static ulong UpdateAndGet(this ref ulong value, Func<ulong, ulong> updater)
  • public static ulong UpdateAndGet(this ref ulong value, method updater)
  • public static ulong UpdateAndGet(this ulong[] array, long index, Func<ulong, ulong> updater)
  • public static ulong UpdateAndGet(this ulong[] array, long index, method updater)
  • public static ulong VolatileRead(this ref ulong value)
  • public static ulong VolatileRead(this ulong[] array, long index)
  • public static void VolatileWrite(this ref ulong value, ulong newValue)
  • public static void VolatileWrite(this ulong[] array, long index, ulong value)
• public struct Lock : IDisposable, IEquatable<Lock>
  • public static Lock Monitor(object obj)
  • public static Lock Monitor(object obj, bool useSpinWait = false)
• public struct ReaderWriterSpinLock
  • public void DowngradeFromWriteLock()
  • public bool TryUpgradeToWriteLock()
  • public bool TryUpgradeToWriteLock(TimeSpan timeout, CancellationToken token = default)
  • public void UpgradeToWriteLock()
• public struct Timeout
  • public const long InfiniteTicks = -10000
  • public const long MaxTimeoutParameterTicks = 21474836470000
  • public static Timeout Expired { get; }
  • public static Timeout Infinite { get; }
  • public TimeSpan? RemainingTime { get; }
  • public bool TryGetRemainingTime(out TimeSpan remainingTime)

DotNext.Threading.Tasks

• public static class CompletedTask<T, TConstant> where TConstant : Constant<T>
  • public static readonly Task<T> Task
• public static class Continuation
  • public static Task<T> ContinueWithTimeout<T>(this Task<T> task, TimeSpan timeout, CancellationToken token = default)
  • public static Task<T> OnCanceled<T, TConstant>(this Task<T> task, TaskScheduler scheduler = null) where TConstant : Constant<T>
  • public static Task<Task> OnCompleted(this Task task)
  • public static Task<Task<TResult>> OnCompleted<TResult>(this Task<TResult> task)
  • public static Task<T> OnFaulted<T, TConstant>(this Task<T> task, TaskScheduler scheduler = null) where TConstant : Constant<T>
  • public static Task<T> OnFaulted<T, TConstant>(this Task<T> task, Predicate<AggregateException> filter, TaskScheduler scheduler = null) where TConstant : Constant<T>
  • public static Task<T> OnFaultedOrCanceled<T, TConstant>(this Task<T> task, TaskScheduler scheduler = null) where TConstant : Constant<T>
  • public static Task<T> OnFaultedOrCanceled<T, TConstant>(this Task<T> task, Predicate<AggregateException> filter, TaskScheduler scheduler = null) where TConstant : Constant<T>
• 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 interface IFuture : INotifyCompletion
  • bool IsCompleted { get; }
• public static class Synchronization
  • public static Result<TResult>? TryGetResult<TResult>(this Task<TResult> task)
  • public static Task<ValueTuple<Result<T1>, Result<T2>>> WhenAll<T1, T2>(Task<T1> task1, Task<T2> task2)
  • public static Task<ValueTuple<Result<T1>, Result<T2>, Result<T3>>> WhenAll<T1, T2, T3>(Task<T1> task1, Task<T2> task2, Task<T3> task3)
  • public static Task<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>>> WhenAll<T1, T2, T3, T4>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4)
  • public static Task<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>, Result<T5>>> WhenAll<T1, T2, T3, T4, T5>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4, Task<T5> task5)
  • public static ValueTask WhenAll(ValueTask task1, ValueTask task2)
  • public static ValueTask<ValueTuple<Result<T1>, Result<T2>>> WhenAll<T1, T2>(ValueTask<T1> task1, ValueTask<T2> task2)
  • public static ValueTask WhenAll(ValueTask task1, ValueTask task2, ValueTask task3)
  • public static ValueTask<ValueTuple<Result<T1>, Result<T2>, Result<T3>>> WhenAll<T1, T2, T3>(ValueTask<T1> task1, ValueTask<T2> task2, ValueTask<T3> task3)
  • public static ValueTask WhenAll(ValueTask task1, ValueTask task2, ValueTask task3, ValueTask task4)
  • public static ValueTask<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>>> WhenAll<T1, T2, T3, T4>(ValueTask<T1> task1, ValueTask<T2> task2, ValueTask<T3> task3, ValueTask<T4> task4)
  • public static ValueTask WhenAll(ValueTask task1, ValueTask task2, ValueTask task3, ValueTask task4, ValueTask task5)
  • public static ValueTask<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>, Result<T5>>> WhenAll<T1, T2, T3, T4, T5>(ValueTask<T1> task1, ValueTask<T2> task2, ValueTask<T3> task3, ValueTask<T4> task4, ValueTask<T5> task5)
  • public static Task<bool> WaitAsync(this Task task, TimeSpan timeout, CancellationToken token = default)
  • public static Task<ValueTuple<T1, T2>> WhenAll<T1, T2>(Task<T1> task1, Task<T2> task2)
  • public static Task<ValueTuple<T1, T2, T3>> WhenAll<T1, T2, T3>(Task<T1> task1, Task<T2> task2, Task<T3> task3)
  • public static Task<ValueTuple<T1, T2, T3, T4>> WhenAll<T1, T2, T3, T4>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4)
  • public static Task<ValueTuple<T1, T2, T3, T4, T5>> WhenAll<T1, T2, T3, T4, T5>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4, Task<T5> task5)

DotNext.VariantType

• public interface IVariant : IDynamicMetaObjectProvider
  • object Value { get; }
  • bool Equals<TVariant>(TVariant other) where TVariant : IVariant
• public struct Variant<T1, T2> : IEquatable<Variant<T1, T2>>, IVariant, IDynamicMetaObjectProvider
  • public Optional<T1> First { get; }
  • public bool IsNull { get; }
  • public Optional<T2> Second { get; }
  • public Variant(T1 value)
  • public Variant(T2 value)
  • public static bool op_Equality(Variant<T1, T2> first, Variant<T1, T2> second)
  • public static T1 op_Explicit(Variant<T1, T2> var)
  • public static T2 op_Explicit(Variant<T1, T2> var)
  • public static bool op_False(Variant<T1, T2> variant)
  • public static Variant<T1, T2> op_Implicit(T1 value)
  • public static Variant<T1, T2> op_Implicit(T2 value)
  • public static bool op_Inequality(Variant<T1, T2> first, Variant<T1, T2> second)
  • public static bool op_True(Variant<T1, T2> variant)
  • public Optional<TResult> Convert<TResult>(Converter<T1, TResult> mapper1, Converter<T2, TResult> mapper2)
  • public Optional<TResult> Convert<TResult>(method mapper1, method mapper2)
  • public Variant<TResult1, TResult2> Convert<TResult1, TResult2>(Converter<T1, TResult1> mapper1, Converter<T2, TResult2> mapper2)
  • public Variant<TResult1, TResult2> Convert<TResult1, TResult2>(method mapper1, method mapper2)
  • public void Deconstruct(out T1 value1, out T2 value2)
  • public bool Equals<TOther>(TOther other) where TOther : IVariant
  • public Variant<T2, T1> Permute()
• public struct Variant<T1, T2, T3> : IVariant, IDynamicMetaObjectProvider, IEquatable<Variant<T1, T2, T3>>
  • public bool IsNull { get; }
  • public Variant(T1 value)
  • public Variant(T2 value)
  • public Variant(T3 value)
  • public static bool op_Equality(Variant<T1, T2, T3> first, Variant<T1, T2, T3> second)
  • public static T1 op_Explicit(Variant<T1, T2, T3> var)
  • public static T2 op_Explicit(Variant<T1, T2, T3> var)
  • public static T3 op_Explicit(Variant<T1, T2, T3> var)
  • public static bool op_False(Variant<T1, T2, T3> variant)
  • public static Variant<T1, T2, T3> op_Implicit(T1 value)
  • public static Variant<T1, T2, T3> op_Implicit(T2 value)
  • public static Variant<T1, T2, T3> op_Implicit(T3 value)
  • public static Variant<T1, T2, T3> op_Implicit(Variant<T1, T2> variant)
  • public static bool op_Inequality(Variant<T1, T2, T3> first, Variant<T1, T2, T3> second)
  • public static bool op_True(Variant<T1, T2, T3> variant)
  • public void Deconstruct(out T1 value1, out T2 value2, out T3 value3)
  • public bool Equals<TOther>(TOther other) where TOther : IVariant
  • public Variant<T3, T1, T2> Permute()
• public struct Variant<T1, T2, T3, T4> : IVariant, IDynamicMetaObjectProvider, IEquatable<Variant<T1, T2, T3, T4>>
  • public bool IsNull { get; }
  • public Variant(T1 value)
  • public Variant(T2 value)
  • public Variant(T3 value)
  • public Variant(T4 value)
  • public static bool op_Equality(Variant<T1, T2, T3, T4> first, Variant<T1, T2, T3, T4> second)
  • public static T1 op_Explicit(Variant<T1, T2, T3, T4> var)
  • public static T2 op_Explicit(Variant<T1, T2, T3, T4> var)
  • public static T3 op_Explicit(Variant<T1, T2, T3, T4> var)
  • public static T4 op_Explicit(Variant<T1, T2, T3, T4> var)
  • public static bool op_False(Variant<T1, T2, T3, T4> variant)
  • public static Variant<T1, T2, T3, T4> op_Implicit(T1 value)
  • public static Variant<T1, T2, T3, T4> op_Implicit(T2 value)
  • public static Variant<T1, T2, T3, T4> op_Implicit(T3 value)
  • public static Variant<T1, T2, T3, T4> op_Implicit(T4 value)
  • public static Variant<T1, T2, T3, T4> op_Implicit(Variant<T1, T2, T3> variant)
  • public static Variant<T1, T2, T3, T4> op_Implicit(Variant<T1, T2> variant)
  • public static bool op_Inequality(Variant<T1, T2, T3, T4> first, Variant<T1, T2, T3, T4> second)
  • public static bool op_True(Variant<T1, T2, T3, T4> variant)
  • public void Deconstruct(out T1 value1, out T2 value2, out T3 value3, out T4 value4)
  • public bool Equals<TOther>(TOther other) where TOther : IVariant
  • public Variant<T4, T1, T2, T3> Permute()