DotNext by .NET Foundation and Contributors

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

---

API Diff between 4.13.1 and 4.0.0-beta.4

482 Additions 38 Removals

DotNext

• public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : struct
  • public static int GetHashCode(ref T value, int hash, method hashFunction, bool salted = true)
  • public static int GetHashCode<THashFunction>(ref T value, bool salted = true) where THashFunction : struct, IConsumer<int>, ISupplier<int>
• 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 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>, IFunctional<Action<T>>, IEquatable<DelegatingConsumer<T>>
  • public static DelegatingConsumer<T> op_Implicit(Action<T> action)
• public abstract class Disposable : IDisposable
  • protected bool IsDisposing { get; }
  • protected bool IsDisposingOrDisposed { get; }
  • protected bool TryBeginDispose()
• public static class EnumConverter
  • public static TypeCode GetTypeCode<TEnum>() where TEnum : struct, Enum
• public static class Func
  • public static Func<T, T> Identity<T>(this Action<T> action)
• public interface IBuildable<TSelf, TBuilder> where TSelf : IBuildable<TSelf, TBuilder> where TBuilder : ISupplier<TSelf>, IResettable
  • TBuilder CreateBuilder()
• public interface IOptionMonad<T> : ISupplier<object>, IFunctional<Func<object>>
  • bool HasValue { get; }
  • T Or(T defaultValue)
  • T OrDefault()
  • T OrInvoke(Func<T> defaultFunc)
  • bool TryGet(out T value)
• 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)
  • TSelf op_Implicit(T value)
  • bool op_True(ref TSelf container)
• public interface IResettable
  • void Reset()
• public interface IResultMonad<T, TError> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>
  • TError Error { get; }
  • T OrInvoke(Func<TError, T> defaultFunc)
• 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>
  • TSelf FromError(TError error)
  • Optional<T> op_Implicit(ref TSelf result)
• public static class OneDimensionalArray
  • 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 int BitwiseHashCode<T, THashFunction>(this T[] array, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where THashFunction : struct, IConsumer<int>, ISupplier<int>
  • 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, THashFunction>(this T[] array, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where THashFunction : struct, IConsumer<long>, ISupplier<long>
  • public static void InstantiateElements<T>(this T[] array)
  • public static bool IsNullOrEmpty<T>(this T[] array)
  • public static T[] Insert<T>(this T[] array, T element, Index index)
  • public static bool IsNullOrEmpty(this Array array)
  • public static T[] RemoveAt<T>(this T[] array, Index index)
• 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>(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 static bool IsValueDefined(T value)
• public static class Predicate
  • public static Predicate<T> Constant<T>(bool value)
• 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 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 static T? OrNull<T, TError>(this ref Result result) where T : struct where TError : struct, Enum
• 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 TError Error { get; }
  • public bool IsSuccessful { get; }
  • public T Value { get; }
  • public Result(T value)
  • public Result(TError error)
  • public static bool op_BitwiseAnd(ref Result left, ref Result right)
  • public static T op_Explicit(ref Result result)
  • public static bool op_False(ref Result result)
  • public static Optional<T> op_Implicit(ref Result result)
  • public static Result<T> op_Implicit(ref Result result)
  • public static Result<T, TError> op_Implicit(T result)
  • public static bool op_True(ref Result result)
  • public Result<object, TError> Box()
  • public Result<TResult, TError> Convert<TResult>(Converter<T, TResult> converter)
  • public Result<TResult, TError> Convert<TResult>(method converter)
  • public T Or(T defaultValue)
  • public T OrDefault()
  • public T OrInvoke(Func<T> defaultFunc)
  • public T OrInvoke(method defaultFunc)
  • public T OrInvoke(Func<TError, T> defaultFunc)
  • public T OrInvoke(method defaultFunc)
  • public T OrThrow(Func<TError, Exception> exceptionFactory)
  • public T OrThrow(method exceptionFactory)
  • public Result<T> ToResult()
  • public bool TryGet(out T value)
  • public Optional<T> TryGet()
• public static class Span
  • 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, 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, method 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, method 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, method 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 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)
  • public static Optional<T> FirstOrNone<T>(this ReadOnlySpan<T> span, Predicate<T> filter)
  • public static void Initialize<T>(this Span<T> span)
  • public static Optional<T> LastOrNone<T>(this ReadOnlySpan<T> span)
  • public static Span<T> TrimLength<T>(this Span<T> span, int maxLength, out Span rest)
• public sealed class UndefinedResultException<TError> : Exception where TError : struct, Enum
  • public TError ErrorCode { get; }
• public struct UserDataSlot<TValue> : IEquatable<UserDataSlot<TValue>>
  • public bool IsAllocated { get; }
  • public UserDataSlot()
• public struct UserDataStorage
  • public bool IsValid { get; }
  • public IReadOnlyDictionary<string, object> Capture()

DotNext.Buffers

• public static class BufferHelpers
  • public static void Concat(this ref BufferWriterSlim writer, ReadOnlySpan<string> values)
  • public static void Concat(this IBufferWriter<char> writer, ReadOnlySpan<string> values)
  • public static Half ReadHalf(this ref SpanReader reader, bool isLittleEndian)
  • public static ReadOnlySequence<char> ToReadOnlySequence(this IEnumerable<string> strings)
  • public static void WriteHalf(this ref BufferWriterSlim builder, Half value, bool isLittleEndian)
  • public static void WriteHalf(this ref SpanWriter writer, Half value, bool isLittleEndian)
• 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 MemoryOwner<T> : IMemoryOwner<T>, IDisposable, ISupplier<Memory<T>>, IFunctional<Func<Memory<T>>>, ISupplier<ReadOnlyMemory<T>>, IFunctional<Func<ReadOnlyMemory<T>>>
  • public Span<T> Span { get; }
  • public bool TryGetArray(out ArraySegment segment)
• public sealed class PooledArrayBufferWriter<T> : BufferWriter<T>, ISupplier<ArraySegment<T>>, IFunctional<Func<ArraySegment<T>>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
  • public PooledArrayBufferWriter()
  • public PooledArrayBufferWriter()
• public sealed class PooledBufferWriter<T> : BufferWriter<T>, IMemoryOwner<T>, IDisposable
  • public PooledBufferWriter()
• 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 static class ReadOnlySequencePartitioner
  • public static OrderablePartitioner<T> CreatePartitioner<T>(this ref ReadOnlySequence sequence, bool splitOnSegments = false)
• public struct SpanWriter<T>
  • 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, 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 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 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 ReverseEndianness(this Span<short> buffer)
  • public static void ReverseEndianness(this Span<ushort> buffer)
  • public static void ReverseEndianness(this Span<int> buffer)
  • public static void ReverseEndianness(this Span<uint> buffer)
  • public static void ReverseEndianness(this Span<long> buffer)
  • public static void ReverseEndianness(this Span<ulong> buffer)

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> output)
  • public void DecodeFromUtf16(ref ReadOnlySequence chars, IBufferWriter<byte> output)
  • public MemoryOwner<byte> DecodeFromUtf16(ReadOnlySpan<char> chars, MemoryAllocator<byte> allocator = null)
  • public void DecodeFromUtf16<TConsumer>(ReadOnlySpan<char> chars, TConsumer output) where TConsumer : IReadOnlySpanConsumer<byte>
  • public void DecodeFromUtf16<TArg>(ReadOnlySpan<char> chars, ReadOnlySpanAction<byte, TArg> callback, TArg arg)
  • public void DecodeFromUtf16<TArg>(ReadOnlySpan<char> chars, method callback, TArg arg)
  • public void DecodeFromUtf8(ReadOnlySpan<byte> utf8Chars, IBufferWriter<byte> output)
  • public void DecodeFromUtf8(ref ReadOnlySequence utf8Chars, IBufferWriter<byte> output)
  • public MemoryOwner<byte> DecodeFromUtf8(ReadOnlySpan<byte> utf8Chars, MemoryAllocator<byte> allocator = null)
  • public void DecodeFromUtf8<TConsumer>(ReadOnlySpan<byte> utf8Chars, TConsumer output) where TConsumer : IReadOnlySpanConsumer<byte>
  • public void DecodeFromUtf8<TArg>(ReadOnlySpan<byte> utf8Chars, ReadOnlySpanAction<byte, TArg> output, TArg arg)
  • public void DecodeFromUtf8<TArg>(ReadOnlySpan<byte> utf8Chars, method output, TArg arg)
  • public void DecodeFromUtf8(ReadOnlySpan<byte> utf8Chars, Stream output)
  • public void Reset()
• public struct Base64Encoder : IResettable
  • public const int MaxBufferedDataSize = 2
  • public const int MaxCharsToFlush = 4
  • public const int MaxInputSize = 1610612733
  • public int BufferedDataSize { get; }
  • public bool HasBufferedData { get; }
  • public static IAsyncEnumerable<ReadOnlyMemory<char>> EncodeToCharsAsync(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 void EncodeToChars(ReadOnlySpan<byte> bytes, IBufferWriter<char> output, bool flush = false)
  • public MemoryOwner<char> EncodeToChars(ReadOnlySpan<byte> bytes, MemoryAllocator<char> allocator = null, bool flush = false)
  • public void EncodeToChars<TConsumer>(ReadOnlySpan<byte> bytes, TConsumer output, bool flush = false) where TConsumer : IReadOnlySpanConsumer<char>
  • public void EncodeToChars<TArg>(ReadOnlySpan<byte> bytes, ReadOnlySpanAction<char, TArg> output, TArg arg, bool flush = false)
  • public void EncodeToChars<TArg>(ReadOnlySpan<byte> bytes, method output, TArg arg, bool flush = false)
  • public void EncodeToChars(ReadOnlySpan<byte> bytes, TextWriter output, bool flush = false)
  • public void EncodeToChars(ReadOnlySpan<byte> bytes, StringBuilder output, bool flush = false)
  • public void EncodeToUtf8(ReadOnlySpan<byte> bytes, IBufferWriter<byte> output, bool flush = false)
  • public MemoryOwner<byte> EncodeToUtf8(ReadOnlySpan<byte> bytes, MemoryAllocator<byte> allocator = null, bool flush = false)
  • public void EncodeToUtf8<TConsumer>(ReadOnlySpan<byte> bytes, TConsumer output, bool flush = false) where TConsumer : IReadOnlySpanConsumer<byte>
  • public void EncodeToUtf8<TArg>(ReadOnlySpan<byte> bytes, ReadOnlySpanAction<byte, TArg> output, TArg arg, bool flush = false)
  • public void EncodeToUtf8<TArg>(ReadOnlySpan<byte> bytes, method output, TArg arg, bool flush = false)
  • public void EncodeToUtf8(ReadOnlySpan<byte> bytes, Stream output, bool flush = false)
  • public int Flush(Span<char> output)
  • public int Flush(Span<byte> output)
  • public int GetBufferedData(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 Dictionary
  • public static IReadOnlyDictionary<TKey, TValue> Empty<TKey, TValue>()
• public static class Sequence
  • public static Task<MemoryOwner<T>> CopyAsync<T>(this IAsyncEnumerable<T> enumerable, int sizeHint = 0, MemoryAllocator<T> allocator = null, CancellationToken token = default)
  • public static Optional<T> FirstOrNone<T>(this IEnumerable<T> seq)
  • public static Optional<T> FirstOrNone<T>(this IEnumerable<T> seq, Predicate<T> filter)
  • 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 IAsyncEnumerable<T> GetEmptyAsyncEnumerable<T>()
  • public static Optional<T> LastOrNone<T>(this IEnumerable<T> seq)
  • public static ValueTask<Optional<T>> LastOrNoneAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default)
  • public static T? LastOrNull<T>(this IEnumerable<T> seq) where T : struct
  • public static ValueTask<T?> LastOrNullAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default) where T : struct
  • public static int SequenceHashCode(this IEnumerable<object> sequence, bool salted = true)
  • public static int SequenceHashCode<T>(this IEnumerable<T> sequence, bool salted = true)
  • public static IEnumerator<T> ToEnumerator<T>(ref ReadOnlySequence sequence)

DotNext.Collections.Specialized

• public class ConcurrentTypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>
  • public struct Enumerator<TValue>
  • public Enumerator<TValue> GetEnumerator()
  • public bool Set<TKey>(TValue newValue, out TValue oldValue)
• public static class InvocationList
  • 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 interface ITypeMap<TValue> : IReadOnlyTypeMap<TValue>
  • bool Set<TKey>(TValue newValue, out TValue oldValue)
• public struct SingletonList<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IList<T>, ICollection<T>, ITuple
  • public struct Enumerator<T> : IEnumerator<T>, IEnumerator, IDisposable
  • public T this[int index] { get; set; }
  • public T Item { get; set; }
  • public SingletonList(T item)
  • public static SingletonList<T> op_Implicit(T item)
  • public Enumerator<T> GetEnumerator()
• public class TypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>
  • public struct Enumerator<TValue>
  • public Enumerator<TValue> GetEnumerator()
  • public bool Set<TKey>(TValue newValue, out TValue oldValue)

DotNext.Diagnostics

• public struct Timestamp : IEquatable<Timestamp>, IComparable<Timestamp>
  • 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 TimeSpan op_Explicit(Timestamp stamp)
  • public static TimeSpan op_Implicit(Timestamp stamp)
  • public static void Refresh(ref Timestamp location)
  • public double ElapsedSince(Timestamp past)

DotNext.Numerics

• public static class BitVector
  • public static void FromByte(byte value, Span<bool> bits)
  • public static void FromInt(IntPtr value, Span<bool> bits)
  • public static void FromInt16(short value, Span<bool> bits)
  • public static void FromInt32(int value, Span<bool> bits)
  • public static void FromInt64(long value, Span<bool> bits)
  • public static void FromSByte(sbyte value, Span<bool> bits)
  • public static void FromUInt(UIntPtr value, Span<bool> bits)
  • public static void FromUInt16(ushort value, Span<bool> bits)
  • public static void FromUInt32(uint value, Span<bool> bits)
  • public static void FromUInt64(ulong value, Span<bool> bits)
  • public static IntPtr ToInt(ReadOnlySpan<bool> bits)
  • public static sbyte ToSByte(ReadOnlySpan<bool> bits)
  • public static UIntPtr ToUInt(ReadOnlySpan<bool> bits)

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)

DotNext.Runtime

• public abstract class BoxedValue<T> where T : struct
  • public ref T Value { get; }
  • 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 BoxedValue<T> TryBox(ref Nullable value)
  • public BoxedValue<T> Copy()
  • 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 int AlignOf<T>()
  • public static void ClearBits(Void* address, long length)
  • public static int Compare(Void* first, Void* second, long length)
  • public static void ClearBits(Void* address, IntPtr length)
  • public static void ClearBits(Void* address, UIntPtr 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, UIntPtr count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static bool Equals(Void* first, Void* second, long length)
  • public static bool Equals(Void* first, Void* second, IntPtr length)
  • public static bool Equals(Void* first, Void* second, UIntPtr length)
  • public static void Finalize(object obj)
  • 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 int GetHashCode32(Void* source, IntPtr length, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode32(Void* source, UIntPtr 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<THashFunction>(Void* source, UIntPtr length, bool salted = true) where THashFunction : struct, IConsumer<int>, ISupplier<int>
  • public static int GetHashCode32(Void* source, IntPtr length, bool salted = true)
  • public static int GetHashCode32(Void* source, UIntPtr length, 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 long GetHashCode64(Void* source, IntPtr length, long hash, Func<long, long, long> hashFunction, bool salted = true)
  • public static long GetHashCode64(Void* source, UIntPtr 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<THashFunction>(Void* source, UIntPtr length, bool salted = true) where THashFunction : struct, IConsumer<long>, ISupplier<long>
  • public static long GetHashCode64(Void* source, IntPtr length, bool salted = true)
  • public static long GetHashCode64(Void* source, UIntPtr length, bool salted = true)
  • public static bool HasFinalizer(object obj)
  • public static bool IsAtomic<T>()
• public sealed class SoftReference<T> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>
  • public ValueTuple<T, SoftReferenceState> TargetAndState { get; }
  • public SoftReference(T target, SoftReferenceOptions options = null)
  • public static T op_Explicit(SoftReference<T> reference)
  • public static Optional<T> op_Explicit(SoftReference<T> reference)
  • public void Clear()
  • public bool TryGetTarget(out T target)
  • public Optional<T> TryGetTarget()
• public class SoftReferenceOptions
  • public static SoftReferenceOptions Default { get; }
  • public int CollectionCount { get; set; }
  • public long MemoryLimit { get; set; }
  • public double MemoryThreshold { get; set; }
  • public SoftReferenceOptions()
• public enum SoftReferenceState
  • Empty = 0
  • Strong = 2
  • Weak = 1

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 RuntimeFeaturesAttribute : Attribute
• 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 sealed class Shared<T> where T : struct
  • public T Value
  • public Shared()
  • public static Shared<T> op_Implicit(ref Nullable value)
  • public static Shared<T> op_Implicit(T value)
• public struct SpawningAsyncTaskMethodBuilder
  • public Task Task { get; }
  • 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 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

DotNext.Text

• public struct Base64Decoder
  • public static IAsyncEnumerable<ReadOnlyMemory<byte>> DecodeAsync(IAsyncEnumerable<ReadOnlyMemory<char>> chars, MemoryAllocator<byte> allocator = null, CancellationToken token = default)
  • public static IAsyncEnumerable<ReadOnlyMemory<byte>> DecodeAsync(IAsyncEnumerable<ReadOnlyMemory<byte>> utf8Chars, MemoryAllocator<byte> allocator = null, CancellationToken token = default)
  • public MemoryOwner<byte> Decode(ReadOnlySpan<char> chars, MemoryAllocator<byte> allocator = null)
  • public MemoryOwner<byte> Decode(ReadOnlySpan<byte> utf8Chars, MemoryAllocator<byte> allocator = null)
  • public void Reset()
• public struct Base64Encoder
  • public const int MaxBufferedDataSize = 2
  • public const int MaxCharsToFlush = 4
  • public const int MaxInputSize = 1610612733
  • public int BufferedDataSize { get; }
  • public bool HasBufferedData { get; }
  • public static IAsyncEnumerable<ReadOnlyMemory<char>> EncodeToCharsAsync(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 void EncodeToChars(ReadOnlySpan<byte> bytes, IBufferWriter<char> output, bool flush = false)
  • public MemoryOwner<char> EncodeToChars(ReadOnlySpan<byte> bytes, MemoryAllocator<char> allocator = null, bool flush = false)
  • public void EncodeToChars<TConsumer>(ReadOnlySpan<byte> bytes, TConsumer output, bool flush = false) where TConsumer : IReadOnlySpanConsumer<char>
  • public void EncodeToChars<TArg>(ReadOnlySpan<byte> bytes, ReadOnlySpanAction<char, TArg> output, TArg arg, bool flush = false)
  • public void EncodeToChars<TArg>(ReadOnlySpan<byte> bytes, method output, TArg arg, bool flush = false)
  • public void EncodeToChars(ReadOnlySpan<byte> bytes, TextWriter output, bool flush = false)
  • public void EncodeToChars(ReadOnlySpan<byte> bytes, StringBuilder output, bool flush = false)
  • public void EncodeToUtf8(ReadOnlySpan<byte> bytes, IBufferWriter<byte> output, bool flush = false)
  • public MemoryOwner<byte> EncodeToUtf8(ReadOnlySpan<byte> bytes, MemoryAllocator<byte> allocator = null, bool flush = false)
  • public void EncodeToUtf8<TConsumer>(ReadOnlySpan<byte> bytes, TConsumer output, bool flush = false) where TConsumer : IReadOnlySpanConsumer<byte>
  • public void EncodeToUtf8<TArg>(ReadOnlySpan<byte> bytes, ReadOnlySpanAction<byte, TArg> output, TArg arg, bool flush = false)
  • public void EncodeToUtf8<TArg>(ReadOnlySpan<byte> bytes, method output, TArg arg, bool flush = false)
  • public void EncodeToUtf8(ReadOnlySpan<byte> bytes, Stream output, bool flush = false)
  • public int Flush(Span<char> output)
  • public int Flush(Span<byte> output)
  • public int GetBufferedData(Span<byte> output)
  • public void Reset()
• public static class InterpolatedString
  • public static MemoryOwner<char> Allocate(MemoryAllocator<char> allocator, IFormatProvider provider, ref PoolingInterpolatedStringHandler handler)
  • public static MemoryOwner<char> Allocate(MemoryAllocator<char> allocator, ref PoolingInterpolatedStringHandler handler)
• public struct StringBuilderConsumer : IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IEquatable<StringBuilderConsumer>
  • public bool IsEmpty { get; }
  • public StringBuilderConsumer(StringBuilder builder)
  • public static bool op_Equality(StringBuilderConsumer left, StringBuilderConsumer right)
  • public static StringBuilderConsumer op_Implicit(StringBuilder builder)
  • public static bool op_Inequality(StringBuilderConsumer left, StringBuilderConsumer right)
  • public bool Equals(StringBuilderConsumer other)

DotNext.Text.Json

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

DotNext.Threading

• public static class AtomicDouble
  • public static double Add(this ref double value, double operand)
  • public static double AddAndGet(this ref double value, double operand)
  • public static double GetAndAdd(this ref double value, double operand)
• public static class AtomicInt32
  • public static int Add(this ref int value, int operand)
  • public static int AddAndGet(this ref int value, int operand)
  • public static int BitwiseAndAndGet(this ref int value, int operand)
  • public static int BitwiseOrAndGet(this ref int value, int operand)
  • public static int BitwiseXorAndGet(this ref int value, int operand)
  • public static int GetAndAdd(this ref int value, int operand)
  • public static int GetAndBitwiseAnd(this ref int value, int operand)
  • public static int GetAndBitwiseOr(this ref int value, int operand)
  • public static int GetAndBitwiseXor(this ref int value, int operand)
• public static class AtomicInt64
  • public static long Add(this ref long value, long operand)
  • public static long AddAndGet(this ref long value, long operand)
  • public static long BitwiseAndAndGet(this ref long value, long operand)
  • public static long BitwiseOrAndGet(this ref long value, long operand)
  • public static long BitwiseXorAndGet(this ref long value, long operand)
  • public static long GetAndAdd(this ref long value, long operand)
  • public static long GetAndBitwiseAnd(this ref long value, long operand)
  • public static long GetAndBitwiseOr(this ref long value, long operand)
  • public static long GetAndBitwiseXor(this ref long value, long operand)
• public static class AtomicIntPtr
  • public static IntPtr Add(this ref IntPtr value, IntPtr operand)
  • public static IntPtr AddAndGet(this ref IntPtr value, IntPtr operand)
  • public static IntPtr BitwiseAndAndGet(this ref IntPtr value, IntPtr operand)
  • public static IntPtr BitwiseOrAndGet(this ref IntPtr value, IntPtr operand)
  • public static IntPtr BitwiseXorAndGet(this ref IntPtr value, IntPtr operand)
  • public static IntPtr GetAndAdd(this ref IntPtr value, IntPtr operand)
  • public static IntPtr GetAndBitwiseAnd(this ref IntPtr value, IntPtr operand)
  • public static IntPtr GetAndBitwiseOr(this ref IntPtr value, IntPtr operand)
  • public static IntPtr GetAndBitwiseXor(this ref IntPtr value, IntPtr operand)
• public static class AtomicSingle
  • public static float Add(this ref float value, float operand)
  • public static float AddAndGet(this ref float value, float operand)
  • public static float GetAndAdd(this ref float value, float operand)
• public static class AtomicUInt32
  • public static uint Add(this ref uint value, uint operand)
  • public static uint AddAndGet(this ref uint value, uint operand)
  • public static uint BitwiseAndAndGet(this ref uint value, uint operand)
  • public static uint BitwiseOrAndGet(this ref uint value, uint operand)
  • public static uint BitwiseXorAndGet(this ref uint value, uint operand)
  • public static uint GetAndAdd(this ref uint value, uint operand)
  • public static uint GetAndBitwiseAnd(this ref uint value, uint operand)
  • public static uint GetAndBitwiseOr(this ref uint value, uint operand)
  • public static uint GetAndBitwiseXor(this ref uint value, uint operand)
• public static class AtomicUInt64
  • public static ulong Add(this ref ulong value, ulong operand)
  • public static ulong AddAndGet(this ref ulong value, ulong operand)
  • public static ulong BitwiseAndAndGet(this ref ulong value, ulong operand)
  • public static ulong BitwiseOrAndGet(this ref ulong value, ulong operand)
  • public static ulong BitwiseXorAndGet(this ref ulong value, ulong operand)
  • public static ulong GetAndAdd(this ref ulong value, ulong operand)
  • public static ulong GetAndBitwiseAnd(this ref ulong value, ulong operand)
  • public static ulong GetAndBitwiseOr(this ref ulong value, ulong operand)
  • public static ulong GetAndBitwiseXor(this ref ulong value, ulong operand)
• public struct Timeout
  • public const long InfiniteTicks = -10000
  • public static Timeout Expired { get; }

DotNext.Threading.Tasks

• public static class Synchronization
  • 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)
  • 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)