DotNext by .NET Foundation and Contributors

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

---

API Diff between 4.0.0 and 2.11.0

789 Additions 374 Removals

DotNext

• public struct Activator<T> : ISupplier<T>
• public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : struct
  • public static int GetHashCode(ref T value, int hash, ref ValueFunc hashFunction, bool salted)
  • public static int GetHashCode<THashFunction>(ref T value, bool salted = true) where THashFunction : struct, IConsumer<int>, ISupplier<int>
• public static class Comparison
  • public static ValueFunc<T, T, int> AsValueFunc<T>(this Comparison<T> comparison, bool wrap = false)
  • public static bool Between<T>(this T value, T left, T right, BoundType boundType = 0) where T : IComparable<T>
  • public static bool IsBetween<T>(this T value, T left, T right, BoundType boundType = 0) where T : IComparable<T>
• public struct Consumer<T> : IConsumer<T>
  • public bool IsEmpty { get; }
  • public Consumer(method ptr)
  • public static Action<T> op_Explicit(Consumer<T> consumer)
  • public static Consumer<T> op_Implicit(method ptr)
  • public Action<T> ToDelegate()
• public struct ConsumerClosure<TContext, T> : IConsumer<T>
  • public bool IsEmpty { get; }
  • public ConsumerClosure(method ptr, TContext context)
• public static class Converter
  • public static ValueFunc<TInput, TOutput> AsValueFunc<TInput, TOutput>(this Converter<TInput, TOutput> converter, bool wrap = false)
• public static class DelegateHelpers
  • public static TDelegate CreateDelegate<TDelegate>(this MethodInfo method, object target = null) where TDelegate : Delegate
  • public static RefAction<T, TArgs> CreateDelegate<T, TArgs>(method ptr)
  • public static RefAction<TRef, TArgs> CreateDelegate<T, TRef, TArgs>(method ptr, T obj)
  • public static RefFunc<T, TArgs, TResult> CreateDelegate<T, TArgs, TResult>(method ptr)
  • public static RefFunc<TRef, TArgs, TResult> CreateDelegate<T, TRef, TArgs, TResult>(method ptr, T obj)
  • public static Action CreateDelegate(method ptr)
  • public static Action CreateDelegate<T>(method ptr, T obj)
  • public static Action<T> CreateDelegate<T>(method ptr)
  • public static Action<T1> CreateDelegate<T, T1>(method ptr, T obj)
  • public static Func<TResult> CreateDelegate<TResult>(method ptr)
  • public static Func<TResult> CreateDelegate<T, TResult>(method ptr, T obj)
  • public static Action<T1, T2> CreateDelegate<T1, T2>(method ptr)
  • public static Action<T1, T2> CreateDelegate<T, T1, T2>(method ptr, T obj)
  • public static Func<T, TResult> CreateDelegate<T, TResult>(method ptr)
  • public static Func<TArg, TResult> CreateDelegate<T, TArg, TResult>(method ptr, T obj)
  • public static Action<T1, T2, T3> CreateDelegate<T1, T2, T3>(method ptr)
  • public static Action<T1, T2, T3> CreateDelegate<T, T1, T2, T3>(method ptr, T obj)
  • public static Func<T1, T2, TResult> CreateDelegate<T1, T2, TResult>(method ptr)
  • public static Func<T1, T2, TResult> CreateDelegate<T, T1, T2, TResult>(method ptr, T obj)
  • public static Action<T1, T2, T3, T4> CreateDelegate<T1, T2, T3, T4>(method ptr)
  • public static Action<T1, T2, T3, T4> CreateDelegate<T, T1, T2, T3, T4>(method ptr, T obj)
  • public static Func<T1, T2, T3, TResult> CreateDelegate<T1, T2, T3, TResult>(method ptr)
  • public static Func<T1, T2, T3, TResult> CreateDelegate<T, T1, T2, T3, TResult>(method ptr, T obj)
  • public static Action<T1, T2, T3, T4, T5> CreateDelegate<T1, T2, T3, T4, T5>(method ptr)
  • public static Action<T1, T2, T3, T4, T5> CreateDelegate<T, T1, T2, T3, T4, T5>(method ptr, T obj)
  • public static Func<T1, T2, T3, T4, TResult> CreateDelegate<T1, T2, T3, T4, TResult>(method ptr)
  • public static Func<T1, T2, T3, T4, TResult> CreateDelegate<T, T1, T2, T3, T4, TResult>(method ptr, T obj)
  • public static Action<T1, T2, T3, T4, T5, T6> CreateDelegate<T1, T2, T3, T4, T5, T6>(method ptr)
  • public static Action<T1, T2, T3, T4, T5, T6> CreateDelegate<T, T1, T2, T3, T4, T5, T6>(method ptr, T obj)
  • public static Func<T1, T2, T3, T4, T5, TResult> CreateDelegate<T1, T2, T3, T4, T5, TResult>(method ptr)
  • public static Func<T1, T2, T3, T4, T5, TResult> CreateDelegate<T, T1, T2, T3, T4, T5, TResult>(method ptr, T obj)
  • public static Func<T1, T2, T3, T4, T5, T6, TResult> CreateDelegate<T1, T2, T3, T4, T5, T6, TResult>(method ptr)
  • public static Func<T1, T2, T3, T4, T5, T6, TResult> CreateDelegate<T, T1, T2, T3, T4, T5, T6, TResult>(method ptr, T obj)
  • public static ReadOnlySpanAction<T, TArg> CreateDelegate<T, TArg>(method ptr)
  • public static ReadOnlySpanAction<TItem, TArg> CreateDelegate<T, TItem, TArg>(method ptr, T obj)
  • public static SpanAction<T, TArg> CreateDelegate<T, TArg>(method ptr)
  • public static SpanAction<TItem, TArg> CreateDelegate<T, TItem, TArg>(method ptr, T obj)
• public struct DelegatingConsumer<T> : IConsumer<T>
  • public bool IsEmpty { get; }
  • public DelegatingConsumer(Action<T> action)
  • public static bool op_Equality(DelegatingConsumer<T> x, DelegatingConsumer<T> y)
  • public static bool op_Inequality(DelegatingConsumer<T> x, DelegatingConsumer<T> y)
  • public bool Equals(DelegatingConsumer<T> other)
• public struct DelegatingSupplier<TResult> : ISupplier<TResult>, IEquatable<DelegatingSupplier<TResult>>
  • public bool IsEmpty { get; }
  • public DelegatingSupplier(Func<TResult> func)
  • public static bool op_Equality(DelegatingSupplier<TResult> x, DelegatingSupplier<TResult> y)
  • public static DelegatingSupplier<TResult> op_Implicit(Func<TResult> func)
  • public static bool op_Inequality(DelegatingSupplier<TResult> x, DelegatingSupplier<TResult> y)
  • public bool Equals(DelegatingSupplier<TResult> other)
• public struct DelegatingSupplier<T, TResult> : ISupplier<T, TResult>, IEquatable<DelegatingSupplier<T, TResult>>
  • public bool IsEmpty { get; }
  • public DelegatingSupplier(Func<T, TResult> func)
  • public static bool op_Equality(DelegatingSupplier<T, TResult> x, DelegatingSupplier<T, TResult> y)
  • public static DelegatingSupplier<T, TResult> op_Implicit(Func<T, TResult> func)
  • public static bool op_Inequality(DelegatingSupplier<T, TResult> x, DelegatingSupplier<T, TResult> y)
  • public bool Equals(DelegatingSupplier<T, TResult> other)
• public struct DelegatingSupplier<T1, T2, TResult> : ISupplier<T1, T2, TResult>, IEquatable<DelegatingSupplier<T1, T2, TResult>>
  • public bool IsEmpty { get; }
  • public DelegatingSupplier(Func<T1, T2, TResult> func)
  • public static bool op_Equality(DelegatingSupplier<T1, T2, TResult> x, DelegatingSupplier<T1, T2, TResult> y)
  • public static DelegatingSupplier<T1, T2, TResult> op_Implicit(Func<T1, T2, TResult> func)
  • public static bool op_Inequality(DelegatingSupplier<T1, T2, TResult> x, DelegatingSupplier<T1, T2, TResult> y)
  • public bool Equals(DelegatingSupplier<T1, T2, TResult> other)
• public abstract class Disposable : IDisposable
  • protected static void QueueDispose(IDisposable resource)
  • protected ValueTask DisposeAsync()
  • protected virtual ValueTask DisposeAsyncCore()
  • protected bool TrySetDisposedException(TaskCompletionSource source)
• public struct Enum<TEnum> : IEquatable<TEnum>, IComparable<TEnum>, IFormattable, IEquatable<Enum<TEnum>>, ISerializable, IConvertible<TEnum>, ICustomAttributeProvider where TEnum : struct, Enum
• public static class EnumConverter
  • public static bool IsOneOf<T>(this T value, T[] values) where T : struct, Enum
  • public static TypeCode GetTypeCode<TEnum>() where TEnum : struct, Enum
• public static class EnumerableTuple
• public struct EnumerableTuple<TItem, TTuple> : IReadOnlyList<TItem>, IEnumerable<TItem>, IEnumerable, IReadOnlyCollection<TItem> where TTuple : ITuple
• public static class Func
  • public static Func<T> Constant<T>(T obj)
  • public static Func<object, bool> IsTypeOf<T>()
• public interface ICallable
• public interface ICallable<TDelegate> : ICallable, IConvertible<TDelegate> where TDelegate : Delegate
• public interface IConvertible<T>
• public interface IConsumer<T>
  • void Invoke(T arg)
• public interface IOptionMonad<T>
  • bool HasValue { get; }
  • T Value { get; }
  • T Or(T defaultValue)
  • T OrDefault()
  • T OrInvoke(Func<T> defaultFunc)
  • bool TryGet(out T value)
• public interface IOptionMonad<T, TSelf> : IOptionMonad<T> 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 IResultMonad<T, TError> : IOptionMonad<T>
  • TError Error { get; }
  • T OrInvoke(Func<TError, T> defaultFunc)
• public interface IResultMonad<T, TError, TSelf> : IResultMonad<T, TError>, IOptionMonad<T>, IOptionMonad<T, TSelf> where TSelf : struct, IResultMonad<T, TError, TSelf>
  • TSelf FromError(TError error)
  • Optional<T> op_Implicit(ref TSelf result)
• public interface ISupplier<TResult>
  • TResult Invoke()
• public interface ISupplier<T, TResult>
  • TResult Invoke(T arg)
• public interface ISupplier<T1, T2, TResult>
  • TResult Invoke(T1 arg1, T2 arg2)
• public static class ObjectExtensions
  • public static void Decompose<T, TResult1, TResult2>(this T obj, Func<T, TResult1> decomposer1, Func<T, TResult2> decomposer2, out TResult1 result1, out TResult2 result2)
  • public static void Decompose<T, TResult1, TResult2>(this T obj, ref ValueFunc decomposer1, ref ValueFunc decomposer2, out TResult1 result1, out TResult2 result2)
  • public static ValueTuple<TResult1, TResult2> Decompose<T, TResult1, TResult2>(this T obj, Func<T, TResult1> decomposer1, Func<T, TResult2> decomposer2)
  • public static ValueTuple<TResult1, TResult2> Decompose<T, TResult1, TResult2>(this T obj, ref ValueFunc decomposer1, ref ValueFunc decomposer2)
• public static class OneDimensionalArray
  • public static int BitwiseHashCode<T>(this T[] array, int hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this T[] array, long hash, ref ValueFunc 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, 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 ForEach<T>(this T[] array, ref ValueRefAction action)
  • public static void ForEach<T>(this T[] array, RefAction<T, long> action)
  • public static void ForEach<T>(this T[] array, RefAction<T, IntPtr> action)
  • public static void ForEach<T, TArg>(this T[] array, method action, TArg arg)
  • public static bool IsNullOrEmpty<T>(this T[] array)
  • public static T[] RemoveAll<T>(this T[] array, ref ValueFunc match, out long count)
  • public static T[] Insert<T>(this T[] array, T element, Index index)
  • public static bool IsNullOrEmpty(this Array array)
  • public static T[] RemoveAll<T>(this T[] array, ref ValueFunc match, ref ValueAction callback)
  • public static T[] RemoveAll<T>(this T[] array, method match, out long count)
  • public static T[] RemoveAll<T>(this T[] array, method match, Action<T> callback)
  • public static T[] RemoveAt<T>(this T[] array, Index index)
  • public static ArraySegment<T> Slice<T>(this T[] input, ref Range range)
  • 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 T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T, TException>(ref Optional optional) where T : struct where TException : Exception
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(ref Optional optional, Func<Exception> exceptionFactory) where T : struct
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(ref Optional optional, method exceptionFactory) where T : struct
• public struct Optional<T> : IEquatable<Optional<T>>, IEquatable<T>, IStructuralEquatable, IOptionMonad<T, Optional<T>>, IOptionMonad<T>
  • public static Optional<T> Empty { get; }
  • public static bool IsValueDefined(T value)
  • public Optional<TResult> Convert<TResult>(ref ValueFunc mapper)
  • public Optional<TResult> Convert<TResult>(ref ValueFunc mapper)
  • public Optional<TResult> Convert<TResult>(method mapper)
  • public Optional<TResult> Convert<TResult>(method mapper)
  • public Optional<T> If(ref ValueFunc condition)
  • public Optional<T> If(method condition)
  • public T OrInvoke(ref ValueFunc defaultFunc)
  • public T OrInvoke(method defaultFunc)
  • public T OrThrow<TException>(ref ValueFunc exceptionFactory) where TException : Exception
  • public T OrThrow<TException>(Func<TException> exceptionFactory) where TException : Exception
  • public T OrThrow(Func<Exception> exceptionFactory)
  • public T OrThrow(method exceptionFactory)
• public static class Predicate
  • public static ValueFunc<T, bool> AsValueFunc<T>(this Predicate<T> predicate, bool wrap = false)
  • public static Predicate<object> IsTypeOf<T>()
• public static class RandomExtensions
  • public static string NextString(this Random random, char[] allowedChars, int length)
  • public static string NextString(this RandomNumberGenerator random, char[] allowedChars, int length)
• public static class Result
  • public static Result<T> FromException<T>(Exception e)
  • public static Result<T> FromValue<T>(T value)
  • 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> : IResultMonad<T, Exception, Result<T>>, IResultMonad<T, Exception>, IOptionMonad<T>, IOptionMonad<T, Result<T>>
  • public Result<TResult> Convert<TResult>(ref ValueFunc converter)
  • public Result<TResult> Convert<TResult>(method converter)
  • public T OrInvoke(ref ValueFunc defaultFunc)
  • public T OrInvoke(ref ValueFunc defaultFunc)
  • public T OrInvoke(method defaultFunc)
  • public T OrInvoke(method defaultFunc)
• public struct Result<T, TError> : IResultMonad<T, TError, Result<T, TError>>, IResultMonad<T, TError>, IOptionMonad<T>, 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 Sequence
• public static class ServiceProviderFactory
  • public sealed class Builder : ISupplier<IServiceProvider>
  • public static readonly IServiceProvider Empty
  • public static IServiceProvider Create<T>(T service, IServiceProvider fallback = null)
  • public static IServiceProvider Create<T1, T2>(T1 service1, T2 service2, IServiceProvider fallback = null)
  • public static IServiceProvider Create<T1, T2, T3>(T1 service1, T2 service2, T3 service3, IServiceProvider fallback = null)
  • public static IServiceProvider Create<T1, T2, T3, T4>(T1 service1, T2 service2, T3 service3, T4 service4, IServiceProvider fallback = null)
  • public static IServiceProvider Create<T1, T2, T3, T4, T5>(T1 service1, T2 service2, T3 service3, T4 service4, T5 service5, IServiceProvider fallback = null)
  • public static Func<object[], IServiceProvider, IServiceProvider> CreateDelegatingFactory(Type[] types)
  • public static Func<T, IServiceProvider, IServiceProvider> CreateDelegatingFactory<T>()
  • public static Func<T1, T2, IServiceProvider, IServiceProvider> CreateDelegatingFactory<T1, T2>()
  • public static Func<T1, T2, T3, IServiceProvider, IServiceProvider> CreateDelegatingFactory<T1, T2, T3>()
  • public static Func<T1, T2, T3, T4, IServiceProvider, IServiceProvider> CreateDelegatingFactory<T1, T2, T3, T4>()
  • public static Func<T1, T2, T3, T4, T5, IServiceProvider, IServiceProvider> CreateDelegatingFactory<T1, T2, T3, T4, T5>()
  • public static Func<object[], IServiceProvider> CreateFactory(Type[] types)
  • public static Func<T, IServiceProvider> CreateFactory<T>()
  • public static Func<T1, T2, IServiceProvider> CreateFactory<T1, T2>()
  • public static Func<T1, T2, T3, IServiceProvider> CreateFactory<T1, T2, T3>()
  • public static Func<T1, T2, T3, T4, IServiceProvider> CreateFactory<T1, T2, T3, T4>()
  • public static Func<T1, T2, T3, T4, T5, IServiceProvider> CreateFactory<T1, T2, T3, T4, T5>()
  • public static IServiceProvider FromTuple<T>(T tuple, IServiceProvider fallback = null) where T : struct, ITuple
• 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 BitwiseHashCode<T>(this Span<T> span, int hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this ReadOnlySpan<T> span, int hash, ref ValueFunc 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 long BitwiseHashCode64<T>(this Span<T> span, long hash, ref ValueFunc 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 ReadOnlySpan<T> span, long hash, ref ValueFunc 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, 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<T> Copy<T>(this ReadOnlySpan<T> span, MemoryAllocator<T> allocator = null)
  • public static void ForEach<T>(this Span<T> span, ref ValueRefAction action)
  • public static Optional<T> FirstOrEmpty<T>(this ReadOnlySpan<T> span)
  • public static void ForEach<T, TArg>(this Span<T> span, method action, TArg arg)
  • public static int IndexOf<T>(this ReadOnlySpan<T> span, T value, int startIndex, ref ValueFunc comparer)
  • public static T Read<T>(ref ReadOnlySpan bytes) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Sort<T>(this Span<T> span, IComparer<T> comparison = null)
  • public static void Sort<T>(this Span<T> span, ref ValueFunc comparison)
  • public static void Sort<T>(this Span<T> span, Comparison<T> comparison)
  • public static int IndexOf<T>(this ReadOnlySpan<T> span, T value, int startIndex, method comparer)
  • public static void Initialize<T>(this Span<T> span)
  • public static Optional<T> PeekRandom<T>(this ReadOnlySpan<T> span, Random random)
  • public static void Shuffle<T>(this Span<T> span, Random random)
  • public static void Sort<T>(this Span<T> span, method comparison)
  • public static void Write<T>(ref T value, ref Span output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public static class StringExtensions
  • public static Char& modreq(System.Runtime.InteropServices.InAttribute) GetRawData(string str)
  • public static bool IsEqualIgnoreCase(this string strA, string strB)
  • public static bool IsNullOrEmpty(this StringBuilder builder)
  • public static ChunkSequence<char> Split(string str, int chunkSize)
• public struct Supplier<TResult> : ISupplier<TResult>
  • public bool IsEmpty { get; }
  • public Supplier(method ptr)
  • public static Func<TResult> op_Explicit(Supplier<TResult> supplier)
  • public static Supplier<TResult> op_Implicit(method ptr)
  • public Func<TResult> ToDelegate()
• public struct Supplier<T, TResult> : ISupplier<T, TResult>
  • public bool IsEmpty { get; }
  • public Supplier(method ptr)
  • public static Func<T, TResult> op_Explicit(Supplier<T, TResult> supplier)
  • public static Supplier<T, TResult> op_Implicit(method ptr)
  • public Func<T, TResult> ToDelegate()
• public struct Supplier<T1, T2, TResult> : ISupplier<T1, T2, TResult>
  • public bool IsEmpty { get; }
  • public Supplier(method ptr)
  • public static Func<T1, T2, TResult> op_Explicit(Supplier<T1, T2, TResult> supplier)
  • public static Supplier<T1, T2, TResult> op_Implicit(method ptr)
  • public Func<T1, T2, TResult> ToDelegate()
• public struct SupplierClosure<TContext, TResult> : ISupplier<TResult>
  • public bool IsEmpty { get; }
  • public SupplierClosure(method ptr, TContext context)
• public struct SupplierClosure<TContext, T, TResult> : ISupplier<T, TResult>
  • public bool IsEmpty { get; }
  • public SupplierClosure(method ptr, TContext context)
• public struct SupplierClosure<TContext, T1, T2, TResult> : ISupplier<T1, T2, TResult>
  • public bool IsEmpty { get; }
  • public SupplierClosure(TContext context, method ptr)
• 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 static object[] ToArray<T>(this T tuple) where T : ITuple
• public sealed class UndefinedResultException<TError> : Exception where TError : struct, Enum
  • public TError ErrorCode { get; }
• public struct UserDataStorage
  • public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot, method valueFactory)
  • public TValue GetOrSet<T, TValue>(UserDataSlot<TValue> slot, T arg, method valueFactory)
  • public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot, ref ValueFunc valueFactory)
  • public TValue GetOrSet<T, TValue>(UserDataSlot<TValue> slot, T arg, ref ValueFunc valueFactory)
  • public TValue GetOrSet<T1, T2, TValue>(UserDataSlot<TValue> slot, T1 arg1, T2 arg2, ref ValueFunc valueFactory)
  • public TValue GetOrSet<T1, T2, TValue>(UserDataSlot<TValue> slot, T1 arg1, T2 arg2, method valueFactory)
  • public TValue GetOrSet<TValue, TFactory>(UserDataSlot<TValue> slot, TFactory valueFactory) where TFactory : struct, ISupplier<TValue>
• public struct ValueAction : IValueDelegate<Action>, ICallable<Action>, ICallable, IConvertible<Action>, ISupplier<Action>, IEquatable<ValueAction>
• public struct ValueAction<T> : IValueDelegate<Action<T>>, ICallable<Action<T>>, ICallable, IConvertible<Action<T>>, ISupplier<Action<T>>, IEquatable<ValueAction<T>>, IConsumer<T>
• public struct ValueAction<T1, T2> : IValueDelegate<Action<T1, T2>>, ICallable<Action<T1, T2>>, ICallable, IConvertible<Action<T1, T2>>, ISupplier<Action<T1, T2>>, IEquatable<ValueAction<T1, T2>>
• public struct ValueAction<T1, T2, T3> : IValueDelegate<Action<T1, T2, T3>>, ICallable<Action<T1, T2, T3>>, ICallable, IConvertible<Action<T1, T2, T3>>, ISupplier<Action<T1, T2, T3>>, IEquatable<ValueAction<T1, T2, T3>>
• public struct ValueAction<T1, T2, T3, T4> : IValueDelegate<Action<T1, T2, T3, T4>>, ICallable<Action<T1, T2, T3, T4>>, ICallable, IConvertible<Action<T1, T2, T3, T4>>, ISupplier<Action<T1, T2, T3, T4>>, IEquatable<ValueAction<T1, T2, T3, T4>>
• public struct ValueAction<T1, T2, T3, T4, T5> : IValueDelegate<Action<T1, T2, T3, T4, T5>>, ICallable<Action<T1, T2, T3, T4, T5>>, ICallable, IConvertible<Action<T1, T2, T3, T4, T5>>, ISupplier<Action<T1, T2, T3, T4, T5>>, IEquatable<ValueAction<T1, T2, T3, T4, T5>>
• public struct ValueFunc<TResult> : IValueDelegate<Func<TResult>>, ICallable<Func<TResult>>, ICallable, IConvertible<Func<TResult>>, ISupplier<Func<TResult>>, IEquatable<ValueFunc<TResult>>, ISupplier<TResult>
• public struct ValueFunc<T, TResult> : IValueDelegate<Func<T, TResult>>, ICallable<Func<T, TResult>>, ICallable, IConvertible<Func<T, TResult>>, ISupplier<Func<T, TResult>>, IValueDelegate<Converter<T, TResult>>, ICallable<Converter<T, TResult>>, IConvertible<Converter<T, TResult>>, ISupplier<Converter<T, TResult>>, IEquatable<ValueFunc<T, TResult>>
• public struct ValueFunc<T1, T2, TResult> : IValueDelegate<Func<T1, T2, TResult>>, ICallable<Func<T1, T2, TResult>>, ICallable, IConvertible<Func<T1, T2, TResult>>, ISupplier<Func<T1, T2, TResult>>, IEquatable<ValueFunc<T1, T2, TResult>>, ISupplier<T1, T2, TResult>
• public struct ValueFunc<T1, T2, T3, TResult> : IValueDelegate<Func<T1, T2, T3, TResult>>, ICallable<Func<T1, T2, T3, TResult>>, ICallable, IConvertible<Func<T1, T2, T3, TResult>>, ISupplier<Func<T1, T2, T3, TResult>>, IEquatable<ValueFunc<T1, T2, T3, TResult>>
• public struct ValueFunc<T1, T2, T3, T4, TResult> : IValueDelegate<Func<T1, T2, T3, T4, TResult>>, ICallable<Func<T1, T2, T3, T4, TResult>>, ICallable, IConvertible<Func<T1, T2, T3, T4, TResult>>, ISupplier<Func<T1, T2, T3, T4, TResult>>, IEquatable<ValueFunc<T1, T2, T3, T4, TResult>>
• public struct ValueFunc<T1, T2, T3, T4, T5, TResult> : IValueDelegate<Func<T1, T2, T3, T4, T5, TResult>>, ICallable<Func<T1, T2, T3, T4, T5, TResult>>, ICallable, IConvertible<Func<T1, T2, T3, T4, T5, TResult>>, ISupplier<Func<T1, T2, T3, T4, T5, TResult>>, IEquatable<ValueFunc<T1, T2, T3, T4, T5, TResult>>
• public struct ValueRefAction<T, TArgs> : IValueDelegate<RefAction<T, TArgs>>, ICallable<RefAction<T, TArgs>>, ICallable, IConvertible<RefAction<T, TArgs>>, ISupplier<RefAction<T, TArgs>>, IEquatable<ValueRefAction<T, TArgs>>
• public struct ValueRefFunc<T, TArgs, TResult> : IValueDelegate<RefFunc<T, TArgs, TResult>>, ICallable<RefFunc<T, TArgs, TResult>>, ICallable, IConvertible<RefFunc<T, TArgs, TResult>>, ISupplier<RefFunc<T, TArgs, TResult>>, IEquatable<ValueRefFunc<T, TArgs, TResult>>
• public struct ValueSupplier<T> : ISupplier<T>
  • public ValueSupplier(T value)
  • public static ValueSupplier<T> op_Implicit(T value)
• 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 float EnsureFinite(this float value)
  • public static double EnsureFinite(this double value)
  • 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 IntPtr LeftShift(this IntPtr value, IntPtr bits)
  • public static IntPtr LeftShift(this IntPtr value, int bits)
  • public static UIntPtr LeftShift(this UIntPtr value, IntPtr 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, IntPtr bits)
  • public static IntPtr RightShift(this IntPtr value, int bits)
  • public static UIntPtr RightShift(this UIntPtr value, IntPtr 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 double Normalize(this ulong value)
  • public static double Normalize(this long value)
  • public static float Normalize(this uint value)
  • public static float Normalize(this int value)
  • public static double NormalizeToDouble<T>(this T value, T min, T max) where T : struct, IConvertible, IComparable<T>
  • public static float NormalizeToSingle<T>(this T value, T min, T max) where T : struct, IConvertible, IComparable<T>
  • 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 IntPtr Xor(this IntPtr x, IntPtr y)
  • public static UIntPtr Xor(this UIntPtr x, UIntPtr y)

DotNext.Buffers

• public struct ArrayRental<T> : IMemoryOwner<T>, IDisposable, IConvertible<Memory<T>>, IConvertible<ArraySegment<T>>, IConvertible<MemoryOwner<T>>
• public static class BufferWriterSlim
• public struct BufferConsumer<T> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IEquatable<BufferConsumer<T>>
  • public bool IsEmpty { get; }
  • public BufferConsumer(IBufferWriter<T> output)
  • public static bool op_Equality(BufferConsumer<T> x, BufferConsumer<T> y)
  • public static bool op_Inequality(BufferConsumer<T> x, BufferConsumer<T> y)
  • public bool Equals(BufferConsumer<T> other)
• 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 ReadOnlyMemory<T> TrimLength<T>(this ReadOnlyMemory<T> memory, int maxLength)
  • public static Memory<T> TrimLength<T>(this Memory<T> memory, int maxLength)
  • public static bool 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 Write<T>(this ref SpanWriter writer, T value, ReadOnlySpan<char> format = default, IFormatProvider provider = null) where T : ISpanFormattable
  • public static int WriteAsString<T>(this ref BufferWriterSlim writer, T value, string format = null, IFormatProvider provider = null)
  • public static int WriteAsString<T>(this IBufferWriter<char> writer, T value, string format = null, IFormatProvider provider = null)
  • 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 int WriteFormattable<T>(this ref BufferWriterSlim writer, T value, ReadOnlySpan<char> format = default, IFormatProvider provider = null) where T : ISpanFormattable
  • public static void WriteFormattable<T>(this ref BufferWriterSlim writer, T value) where T : IBinaryFormattable<T>
  • public static void WriteFormattable<T>(this ref BufferWriterSlim writer, ReadOnlySpan<T> values) where T : IBinaryFormattable<T>
  • public static int WriteFormattable<T>(this IBufferWriter<char> writer, T value, ReadOnlySpan<char> format = default, IFormatProvider provider = null) where T : ISpanFormattable
  • public static void WriteFormattable<T>(this IBufferWriter<byte> writer, T value) where T : IBinaryFormattable<T>
  • public static void WriteFormattable<T>(this IBufferWriter<byte> writer, ReadOnlySpan<T> values) where T : IBinaryFormattable<T>
  • 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 WriteLine(this ref BufferWriterSlim writer)
  • public static void WriteLine(this ref BufferWriterSlim writer, ReadOnlySpan<char> characters)
  • public static void WriteLine(this IBufferWriter<char> writer)
  • public static void WriteLine(this IBufferWriter<char> writer, ReadOnlySpan<char> characters)
  • 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 int WriteString(this ref BufferWriterSlim writer, IFormatProvider provider, ref BufferWriterSlimInterpolatedStringHandler handler)
  • public static int WriteString(this ref BufferWriterSlim writer, ref BufferWriterSlimInterpolatedStringHandler handler)
  • public static int WriteString(this IBufferWriter<char> writer, IFormatProvider provider, ref BufferWriterInterpolatedStringHandler handler)
  • public static int WriteString(this IBufferWriter<char> writer, ref BufferWriterInterpolatedStringHandler handler)
  • 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 abstract int Capacity { get; }
  • public int FreeCapacity { get; }
  • public T& modreq(System.Runtime.InteropServices.InAttribute) this[int index] { get; }
  • public int WrittenCount { get; }
  • public abstract ReadOnlyMemory<T> WrittenMemory { get; }
  • public void Add(T item)
  • public virtual void AddAll(ICollection<T> items)
  • public void Advance(int count)
  • public abstract void Clear(bool reuseBuffer = false)
  • public abstract MemoryOwner<T> DetachBuffer()
  • public IEnumerator<T> GetEnumerator()
  • public abstract Memory<T> GetMemory(int sizeHint = 0)
  • public virtual Span<T> GetSpan(int sizeHint = 0)
• public struct BufferWriterInterpolatedStringHandler
  • public int WrittenCount { get; }
  • public BufferWriterInterpolatedStringHandler(int literalLength, int formattedCount, IBufferWriter<char> buffer, IFormatProvider provider = null)
  • public void AppendFormatted<T>(T value, string format = null)
  • public void AppendFormatted(ReadOnlySpan<char> value)
  • public void AppendFormatted(ReadOnlySpan<char> value, int alignment)
  • public void AppendFormatted<T>(T value, int alignment, string format = null)
  • public void AppendLiteral(string value)
• public struct BufferWriterSlim<T>
  • public BufferWriterSlim(Span<T> buffer, bool copyOnOverflow, MemoryAllocator<T> allocator = null)
  • public BufferWriterSlim(Span<T> buffer, MemoryAllocator<T> allocator = null)
  • public BufferWriterSlim(int initialCapacity, MemoryAllocator<T> allocator = null)
  • public void Advance(int count)
  • public void CopyTo(IBufferWriter<T> output)
  • public void CopyTo<TArg>(ReadOnlySpanAction<T, TArg> action, TArg arg)
  • public void CopyTo(ref SpanWriter output)
  • public void CopyTo(Span<T> output)
  • public Span<T> GetSpan(int sizeHint = 0)
  • public bool TryDetachBuffer(out MemoryOwner owner)
• public static class ChunkSequence
• public struct ChunkSequence<T> : IEnumerable<ReadOnlyMemory<T>>, IEnumerable
• public struct BufferWriterSlimInterpolatedStringHandler
  • public int WrittenCount { get; }
  • public BufferWriterSlimInterpolatedStringHandler(int literalLength, int formattedCount, ref BufferWriterSlim buffer, IFormatProvider provider = null)
  • public void AppendFormatted<T>(T value, string format = null)
  • public void AppendFormatted(ReadOnlySpan<char> value)
  • public void AppendFormatted(ReadOnlySpan<char> value, int alignment)
  • public void AppendFormatted<T>(T value, int alignment, string format = null)
  • public void AppendLiteral(string value)
• public struct DelegatingReadOnlySpanConsumer<T, TArg> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>
  • public bool IsEmpty { get; }
  • public DelegatingReadOnlySpanConsumer(ReadOnlySpanAction<T, TArg> action, TArg arg)
• public interface IBinaryFormattable<TSelf> where TSelf : IBinaryFormattable<TSelf>
  • int Size { get; }
  • MemoryOwner<byte> Format(TSelf value, MemoryAllocator<byte> allocator = null)
  • void Format(TSelf value, Span<byte> output)
  • TSelf Parse(ref SpanReader input)
  • TSelf Parse(ReadOnlySpan<byte> input)
  • TSelf Parse(ref ReadOnlySequence input)
  • bool TryFormat(TSelf value, Span<byte> output)
  • bool TryParse(ReadOnlySpan<byte> input, out TSelf result)
  • void Format(ref SpanWriter output)
• public interface IGrowableBuffer<T> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IDisposable
  • long? Capacity { get; }
  • long WrittenCount { get; }
  • void Clear()
  • void CopyTo<TConsumer>(TConsumer consumer) where TConsumer : IReadOnlySpanConsumer<T>
  • int CopyTo(Span<T> output)
  • ValueTask CopyToAsync<TConsumer>(TConsumer consumer, CancellationToken token) where TConsumer : ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>
  • bool TryGetWrittenContent(out ReadOnlyMemory block)
  • void Write(ReadOnlySpan<T> input)
  • void Write(T value)
• public interface IReadOnlySpanConsumer<T> : ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>
  • void Invoke(ReadOnlySpan<T> span)
• public static class MemoryAllocator
  • public static MemoryOwner<T> Allocate<T>(int length, bool exactSize)
• public struct MemoryOwner<T> : IMemoryOwner<T>, IDisposable, ISupplier<Memory<T>>, ISupplier<ReadOnlyMemory<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 TryResize(int newLength)
• public struct MemoryRental<T>
  • public MemoryRental(MemoryPool<T> pool, int minBufferSize)
  • public MemoryRental(MemoryPool<T> pool, int minBufferSize, bool exactSize = true)
  • public MemoryRental(int minBufferSize)
  • public MemoryRental(int minBufferSize, bool exactSize = true)
• public struct MemoryTemplate<T> where T : IEquatable<T>
  • public void Render<TConsumer>(TConsumer consumer) where TConsumer : IReadOnlySpanConsumer<T>, IConsumer<int>
• public abstract class MemoryWriter<T> : Disposable, IBufferWriter<T>, IConvertible<ReadOnlyMemory<T>>, IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>
• public static class PooledArrayBufferWriter
• public sealed class PooledArrayBufferWriter<T> : BufferWriter<T>, ISupplier<ArraySegment<T>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
  • public ref T this[long index] { get; }
  • public void Insert(int index, ReadOnlySpan<T> items)
  • public void Overwrite(int index, ReadOnlySpan<T> items)
• public static class SpanReader
• public static class ReadOnlySequencePartitioner
  • public static OrderablePartitioner<T> CreatePartitioner<T>(this ref ReadOnlySequence sequence, bool splitOnSegments = false)
• public struct ReadOnlySpanConsumer<T, TArg> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>
  • public bool IsEmpty { get; }
  • public ReadOnlySpanConsumer(method ptr, TArg arg)
• public struct SpanReader<T>
  • public ReadOnlySpan<T> RemainingSpan { get; }
  • public void Read(Span<T> output)
  • public SpanReader(ref T reference, int length)
  • public void Advance(int count)
  • public int Read(Span<T> output)
  • public TResult Read<TResult>(method reader, int count)
  • public ReadOnlySpan<T> ReadToEnd()
  • public void Rewind(int count)
  • public bool TryRead<TResult>(method reader, int count, out TResult result)
• public static class SpanWriter
• public struct SpanWriter<T>
  • public Span<T> RemainingSpan { get; }
  • public SpanWriter(ref T reference, int length)
  • public void Advance(int count)
  • public void Rewind(int count)
  • public void Write(ReadOnlySpan<T> input)
  • public bool TryWrite<TArg>(method action, TArg arg)
  • public int Write(ReadOnlySpan<T> input)
  • public void Write<TArg>(method action, TArg arg, int count)
• public enum SparseBufferGrowth
  • Exponential = 2
  • Linear = 1
  • None = 0
• 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 struct Enumerator<T> : IEnumerator<ReadOnlyMemory<T>>, IEnumerator, IDisposable
  • public bool IsSingleSegment { get; }
  • public long WrittenCount { get; }
  • public SparseBufferWriter(int chunkSize, SparseBufferGrowth growth = 0, MemoryAllocator<T> allocator = null)
  • public SparseBufferWriter(MemoryPool<T> pool)
  • public SparseBufferWriter()
  • public void Add(T item)
  • public void Clear()
  • public void CopyTo<TConsumer>(TConsumer consumer) where TConsumer : IReadOnlySpanConsumer<T>
  • public void CopyTo<TArg>(ReadOnlySpanAction<T, TArg> writer, TArg arg)
  • public int CopyTo(Span<T> output)
  • public Enumerator<T> GetEnumerator()
  • public bool TryGetWrittenContent(out ReadOnlyMemory segment)
  • public void Write(ReadOnlySpan<T> input)
  • public void Write(ReadOnlyMemory<T> input, bool copyMemory = true)
  • public void Write(ref ReadOnlySequence sequence, bool copyMemory = true)

DotNext.Collections.Generic

• public static class Collection
  • public static ReadOnlyCollectionView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyCollection<TInput> collection, ref ValueFunc converter)
  • public static Optional<T> PeekRandom<T>(this IReadOnlyCollection<T> collection, Random random)
• public static class Dictionary
  • public static ReadOnlyDictionaryView<TKey, TValue, TResult> ConvertValues<TKey, TValue, TResult>(this IReadOnlyDictionary<TKey, TValue> dictionary, ref ValueFunc mapper)
  • public static void ForEach<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, ref ValueAction action)
  • public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key, ref ValueFunc valueFactory)
  • public static TValue GetOrInvoke<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, ref ValueFunc defaultValue)
  • public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TValue> valueFactory)
  • public static TValue GetOrInvoke<TKey, TValue, TSupplier>(this IDictionary<TKey, TValue> dictionary, TKey key, TSupplier defaultValue) where TSupplier : struct, ISupplier<TValue>
• public static class List
  • public static ReadOnlyListView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyList<TInput> list, ref ValueFunc converter)
  • public static int InsertOrdered<T>(this IList<T> list, T item, ref ValueFunc comparer)
  • public static int InsertOrdered<T, TComparer>(this List<T> list, T item, TComparer comparer) where TComparer : IComparer<T>
  • public static int InsertOrdered<T, TComparer>(this IList<T> list, T item, TComparer comparer) where TComparer : IComparer<T>
  • public static int InsertOrdered<T>(this IList<T> list, T item, method comparer)
  • public static void Shuffle<T>(this IList<T> list, Random random)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, ref ValueFunc mapper)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, ref ValueFunc mapper)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, method mapper)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, method mapper)
• public struct ListSegment<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyList<T>, IReadOnlyCollection<T>
  • public bool TryGetSpan(out Span span)
• public struct ReadOnlyCollectionView<TInput, TOutput> : IReadOnlyCollection<TOutput>, IEnumerable<TOutput>, IEnumerable, IEquatable<ReadOnlyCollectionView<TInput, TOutput>>
  • public ReadOnlyCollectionView(IReadOnlyCollection<TInput> collection, ref ValueFunc mapper)
  • public static bool op_Equality(ReadOnlyCollectionView<TInput, TOutput> first, ReadOnlyCollectionView<TInput, TOutput> second)
  • public static bool op_Inequality(ReadOnlyCollectionView<TInput, TOutput> first, ReadOnlyCollectionView<TInput, TOutput> second)
  • public ReadOnlyCollectionView(IReadOnlyCollection<TInput> collection, Func<TInput, TOutput> mapper)
  • public ReadOnlyCollectionView(IReadOnlyCollection<TInput> collection, Converter<TInput, TOutput> mapper)
  • public static bool op_Equality(ref ReadOnlyCollectionView first, ref ReadOnlyCollectionView second)
  • public static bool op_Inequality(ref ReadOnlyCollectionView first, ref ReadOnlyCollectionView second)
• public struct ReadOnlyDictionaryView<TKey, TInput, TOutput> : IReadOnlyDictionary<TKey, TOutput>, IEnumerable<KeyValuePair<TKey, TOutput>>, IEnumerable, IReadOnlyCollection<KeyValuePair<TKey, TOutput>>, IEquatable<ReadOnlyDictionaryView<TKey, TInput, TOutput>>
  • public ReadOnlyDictionaryView(IReadOnlyDictionary<TKey, TInput> dictionary, ref ValueFunc mapper)
  • public static bool op_Equality(ReadOnlyDictionaryView<TKey, TInput, TOutput> first, ReadOnlyDictionaryView<TKey, TInput, TOutput> second)
  • public static bool op_Inequality(ReadOnlyDictionaryView<TKey, TInput, TOutput> first, ReadOnlyDictionaryView<TKey, TInput, TOutput> second)
  • public ReadOnlyDictionaryView(IReadOnlyDictionary<TKey, TInput> dictionary, Func<TInput, TOutput> mapper)
  • public ReadOnlyDictionaryView(IReadOnlyDictionary<TKey, TInput> dictionary, Converter<TInput, TOutput> mapper)
  • public static bool op_Equality(ref ReadOnlyDictionaryView first, ref ReadOnlyDictionaryView second)
  • public static bool op_Inequality(ref ReadOnlyDictionaryView first, ref ReadOnlyDictionaryView second)
• public struct ReadOnlyListView<TInput, TOutput> : IReadOnlyList<TOutput>, IEnumerable<TOutput>, IEnumerable, IReadOnlyCollection<TOutput>, IEquatable<ReadOnlyListView<TInput, TOutput>>
  • public ReadOnlyListView(IReadOnlyList<TInput> list, ref ValueFunc mapper)
  • public static bool op_Equality(ReadOnlyListView<TInput, TOutput> first, ReadOnlyListView<TInput, TOutput> second)
  • public static bool op_Inequality(ReadOnlyListView<TInput, TOutput> first, ReadOnlyListView<TInput, TOutput> second)
  • public ReadOnlyListView(IReadOnlyList<TInput> list, Func<TInput, TOutput> mapper)
  • public ReadOnlyListView(IReadOnlyList<TInput> list, Converter<TInput, TOutput> mapper)
  • public static bool op_Equality(ref ReadOnlyListView first, ref ReadOnlyListView second)
  • public static bool op_Inequality(ref ReadOnlyListView first, ref ReadOnlyListView second)
• public static class Sequence
  • public struct ConsumingEnumerable<T> : IEnumerable<T>, IEnumerable
  • public static MemoryOwner<T> Copy<T>(this IEnumerable<T> enumerable, int sizeHint = 0, MemoryAllocator<T> allocator = null)
  • public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq, ref ValueFunc filter)
  • public static ValueTask<Optional<T>> FirstOrEmptyAsync<T>(this IAsyncEnumerable<T> seq, ValueFunc<T, bool> filter, CancellationToken token = default)
  • public static void ForEach<T>(this IEnumerable<T> collection, ref ValueAction action)
  • public static ValueTask ForEachAsync<T>(this IAsyncEnumerable<T> collection, ValueAction<T> action, CancellationToken token = default)
  • public static ValueTask ForEachAsync<T>(this IAsyncEnumerable<T> collection, ValueFunc<T, CancellationToken, ValueTask> action, CancellationToken token = default)
  • public static ValueTask ForEachAsync<T>(this IEnumerable<T> collection, ValueFunc<T, CancellationToken, ValueTask> action, CancellationToken token = default)
  • public static ConsumingEnumerable<T> GetConsumer<T>(this IProducerConsumerCollection<T> collection)
  • public static IEnumerator<T> GetEmptyEnumerator<T>()
  • public static AsyncGenerator<T> ToAsyncEnumerable<T>(this Func<CancellationToken, ValueTask<Optional<T>>> generator)
  • public static AsyncGenerator<T> ToAsyncEnumerable<T>(this Func<CancellationToken, ValueTask<Optional<T>>> generator)
  • public static IEnumerator<T> ToEnumerator<T>(ref ReadOnlySequence sequence)
• public static class Stack

DotNext.Collections.Specialized

• public class ConcurrentTypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>
  • public ConcurrentTypeMap(int capacity)
  • public ConcurrentTypeMap()
  • public bool AddOrUpdate<TKey>(TValue value)
  • public void Clear()
  • public bool ContainsKey<TKey>()
  • public TValue GetOrAdd<TKey>(TValue value, out bool added)
  • public bool Remove<TKey>(out TValue value)
  • public bool Remove<TKey>()
  • public Optional<TValue> Replace<TKey>(TValue value)
  • public void Set<TKey>(TValue value)
  • public bool TryAdd<TKey>(TValue value)
  • public bool TryGetValue<TKey>(out TValue value)
• public static class InvocationList
  • public static ReadOnlySpan<TDelegate> AsSpan<TDelegate>(this ref InvocationList delegates) where TDelegate : MulticastDelegate
  • public static void Invoke<T>(this ref InvocationList actions, T arg)
  • public static void Invoke<T1, T2>(this ref InvocationList actions, T1 arg1, T2 arg2)
• public struct InvocationList<TDelegate> : IReadOnlyCollection<TDelegate>, IEnumerable<TDelegate>, IEnumerable where TDelegate : MulticastDelegate
  • public struct Enumerator<TDelegate> where TDelegate : MulticastDelegate
  • public static InvocationList<TDelegate> Empty { get; }
  • public int Count { get; }
  • public bool IsEmpty { get; }
  • public InvocationList(TDelegate d)
  • public static InvocationList<TDelegate> op_Addition(InvocationList<TDelegate> list, TDelegate d)
  • public static InvocationList<TDelegate> op_Subtraction(InvocationList<TDelegate> list, TDelegate d)
  • public InvocationList<TDelegate> Add(TDelegate d)
  • public TDelegate Combine()
  • public Enumerator<TDelegate> GetEnumerator()
  • public InvocationList<TDelegate> Remove(TDelegate d)
• public interface IReadOnlyTypeMap<TValue>
  • bool ContainsKey<TKey>()
  • bool TryGetValue<TKey>(out TValue value)
• public interface ITypeMap<TValue> : IReadOnlyTypeMap<TValue>
  • void Add<TKey>(TValue value)
  • void Clear()
  • bool Remove<TKey>()
  • bool Remove<TKey>(out TValue value)
  • Optional<TValue> Replace<TKey>(TValue value)
  • void Set<TKey>(TValue value)
• public struct SingletonList<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IList<T>, ICollection<T>
  • 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 TypeMap(int capacity)
  • public TypeMap()
  • public void Add<TKey>(TValue value)
  • public void Clear()
  • public bool ContainsKey<TKey>()
  • public ref TValue GetValueRefOrAddDefault<TKey>(out bool exists)
  • public bool Remove<TKey>()
  • public bool Remove<TKey>(out TValue value)
  • public Optional<TValue> Replace<TKey>(TValue value)
  • public void Set<TKey>(TValue value)
  • public bool TryGetValue<TKey>(out TValue value)

DotNext.Diagnostics

• public struct Timestamp : IEquatable<Timestamp>, IComparable<Timestamp>
  • public static Timestamp op_Addition(Timestamp x, TimeSpan y)
  • public static Timestamp op_Subtraction(Timestamp x, TimeSpan y)
  • public static Timestamp VolatileRead(ref Timestamp location)
  • public static void VolatileWrite(ref Timestamp location, Timestamp newValue)
• public sealed class UnreachableCodeExecutionException : Exception

DotNext.IO

• public interface IFlushable
  • Func<T, CancellationToken, Task> TryReflectAsyncFlushMethod<T>(T obj)
  • Action<T> TryReflectFlushMethod<T>(T obj)
  • void DiscoverFlushMethods<T>(T obj, ref Action flush, ref Func flushAsync)
• public struct StreamConsumer : IReadOnlySpanConsumer<byte>, ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>, IEquatable<StreamConsumer>, IFlushable
  • public bool IsEmpty { get; }
  • public StreamConsumer(Stream output)
  • public static bool op_Equality(StreamConsumer x, StreamConsumer y)
  • public static StreamConsumer op_Implicit(Stream output)
  • public static bool op_Inequality(StreamConsumer x, StreamConsumer y)
  • public bool Equals(StreamConsumer other)
• public static class StreamSource
  • public static Stream AsAsynchronousStream<TOutput>(TOutput output) where TOutput : ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>, IFlushable
  • public static Stream AsStream(this SparseBufferWriter<byte> writer, bool readable)
  • public static Stream GetWrittenBytesAsStream(PooledArrayBufferWriter<byte> writer)
  • public static Stream AsSynchronousStream<TOutput>(TOutput output) where TOutput : IFlushable, IReadOnlySpanConsumer<byte>
• public struct TextConsumer : IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFlushable
  • public bool IsEmpty { get; }
  • public TextConsumer(TextWriter output)
  • public static bool op_Equality(TextConsumer x, TextConsumer y)
  • public static TextConsumer op_Implicit(TextWriter output)
  • public static bool op_Inequality(TextConsumer x, TextConsumer y)
  • public bool Equals(TextConsumer other)

DotNext.Net.Http

• public sealed class HttpEndPoint : DnsEndPoint, ISupplier<UriBuilder>, IEquatable<HttpEndPoint>
  • public bool IsSecure { get; }
  • public string Scheme { get; }
  • public HttpEndPoint(Uri uri)
  • public HttpEndPoint(string hostName, int port, bool secure, AddressFamily family = 0)
  • public HttpEndPoint(IPAddress address, int port, bool secure)
  • public HttpEndPoint(IPEndPoint address, bool secure)
  • public static bool op_Equality(HttpEndPoint x, HttpEndPoint y)
  • public static UriBuilder op_Explicit(HttpEndPoint endPoint)
  • public static bool op_Inequality(HttpEndPoint x, HttpEndPoint y)
  • public static bool TryParse(string str, out HttpEndPoint result)
  • public UriBuilder CreateUriBuilder()
  • public bool Equals(HttpEndPoint other)

DotNext.Numerics

• public static class BitVector
  • public static void FromByte(byte 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 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 byte ToByte(ReadOnlySpan<bool> bits)
  • public static short ToInt16(ReadOnlySpan<bool> bits)
  • public static int ToInt32(ReadOnlySpan<bool> bits)
  • public static long ToInt64(ReadOnlySpan<bool> bits)
  • public static sbyte ToSByte(ReadOnlySpan<bool> bits)
  • public static ushort ToUInt16(ReadOnlySpan<bool> bits)
  • public static uint ToUInt32(ReadOnlySpan<bool> bits)
  • public static ulong ToUInt64(ReadOnlySpan<bool> bits)

DotNext.Reflection

• public static class DisposableType
  • public static MethodInfo GetDisposeAsyncMethod(this Type type)
• public static class EnumType
  • public static TAttribute GetCustomAttribute<TEnum, TAttribute>(this TEnum value) where TEnum : struct, Enum where TAttribute : Attribute
  • public static IEnumerable<TAttribute> GetCustomAttributes<TEnum, TAttribute>(this TEnum value) where TEnum : struct, Enum where TAttribute : Attribute
• public static class TaskType
  • public static Func<Task, bool> IsCompletedSuccessfullyGetter { get; }
  • public static Func<Task<T>, T> GetResultGetter<T>()

DotNext.Runtime

• public static class Intrinsics
  • 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 int Compare(Void* first, Void* second, IntPtr length)
  • public static bool Equals(Void* first, Void* second, long length)
  • public static bool Equals(Void* first, Void* second, IntPtr length)
  • 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(Void* source, long length, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode32(Void* source, long length, int hash, ref ValueFunc hashFunction, bool salted = true)
  • public static int GetHashCode32(Void* source, long 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(Void* source, long length, long hash, ref ValueFunc hashFunction, bool salted = true)
  • public static long GetHashCode64(Void* source, long length, bool salted = true)
  • public static UIntPtr GetLength(Array array)
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReadonlyRef<T>(T[] array, long index)
  • public static TBase& modreq(System.Runtime.InteropServices.InAttribute) GetReadonlyRef<T, TBase>(this T[] array, long index) where T : TBase
  • public static int GetHashCode32<T>(Func<T, int, int> getter, int count, T arg, bool salted = true)
  • public static int GetHashCode32(Void* source, IntPtr length, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode32<THashFunction>(Void* source, IntPtr length, bool salted = true) where THashFunction : struct, IConsumer<int>, ISupplier<int>
  • public static int GetHashCode32(Void* source, IntPtr length, bool salted = true)
  • public static long GetHashCode64<T>(Func<T, int, long> getter, int count, T arg, bool salted = true)
  • public static long GetHashCode64(Void* source, IntPtr length, long hash, Func<long, long, long> hashFunction, bool salted = true)
  • public static long GetHashCode64<THashFunction>(Void* source, IntPtr length, bool salted = true) where THashFunction : struct, IConsumer<long>, ISupplier<long>
  • public static long GetHashCode64(Void* source, IntPtr length, bool salted = true)
  • public static IntPtr GetLength(Array array)
  • public static TBase& modreq(System.Runtime.InteropServices.InAttribute) GetReadonlyRef<T, TBase>(this T[] array, IntPtr index) where T : TBase
  • public static bool IsNull<T>(ref T value)
  • public static int PointerHashCode(Void* pointer)
  • public static int ToInt32(bool low, bool high)
• public static class Reference
  • public static Reference<TValue> Allocate<TValue>(TValue value)
  • public static Reference<TValue> ArrayElement<TValue>(TValue[] array, IntPtr index)
  • public static Reference<TValue> Create<TValue>(method getter)
  • public static Reference<TValue> Create<TOwner, TValue>(TOwner owner, method getter)
  • public static Reference<TValue> Field<TValue>(StrongBox<TValue> box)
  • public static Reference<TValue> FromPointer<TValue>(TValue* ptr) where TValue : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static Reference<TValue> Unbox<TValue>(object boxed) where TValue : struct
• public struct Reference<TValue>
  • public bool IsValid { get; }
  • public Span<TValue> Span { get; }
  • public ref TValue Target { get; }

DotNext.Runtime.CompilerServices

• public abstract class AsyncDelegateFuture : Future<Task>, IAwaiter, IFuture, INotifyCompletion
• public struct Box<T> : IEquatable<Box<T>> where T : struct
• public sealed class CallerMustBeSynchronizedAttribute : Attribute
• public struct ManagedMethodPointer : IEquatable<ManagedMethodPointer>
• public sealed class FunctionalInterfaceAttribute : Attribute
  • public FunctionalInterfaceAttribute()
• public sealed class RuntimeFeaturesAttribute : Attribute
  • public bool Augmentation
  • public bool DynamicCodeCompilation
  • public bool PrivateReflection
  • public bool RuntimeGenericInstantiation
  • public bool DynamicCodeCompilation { get; set; }
  • public bool PrivateReflection { get; set; }
  • public bool RuntimeGenericInstantiation { get; set; }
• 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)

DotNext.Runtime.ExceptionServices

• public struct ExceptionAggregator : ISupplier<Exception>
  • public bool IsEmpty { get; }
  • public void Add(Exception e)
  • public Exception CreateException()
  • public void ThrowIfNeeded()

DotNext.Runtime.InteropServices

• public static class SafeBufferExtensions
  • public static ref byte AcquirePointer(this SafeBuffer buffer)

DotNext.Security.Cryptography

• public struct HashBuilder : ICryptoTransform, IDisposable

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)

DotNext.Text.Json

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

DotNext.Threading

• public static class AsyncDelegate
  • public static AsyncDelegateFuture InvokeAsync<TDelegate>(this TDelegate delegate, Action<TDelegate> invoker, CancellationToken token = default) where TDelegate : MulticastDelegate
  • public static AsyncDelegateFuture InvokeAsync<TEventArgs>(this EventHandler<TEventArgs> handler, object sender, TEventArgs args, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync(this EventHandler handler, object sender, EventArgs args, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync(this Action action, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T>(this Action<T> action, T arg, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2>(this Action<T1, T2> action, T1 arg1, T2 arg2, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3>(this Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3, CancellationToken token = default)
  • public static AsyncDelegateFuture 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 AsyncDelegateFuture 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 AsyncDelegateFuture 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 AsyncDelegateFuture 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 AsyncDelegateFuture 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 AsyncDelegateFuture 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 AsyncDelegateFuture 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 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 struct Atomic<T> : IStrongBox, ICloneable where T : struct
  • public bool CompareAndSet(Func<T, T, bool> comparer, ref T expected, ref T update)
  • public bool CompareAndSet(method comparer, ref T expected, ref T update)
  • public bool CompareExchange(Func<T, T, bool> comparer, ref T update, ref T expected, out T result)
  • public bool CompareExchange(method comparer, ref T update, ref T expected, out T result)
• public struct AtomicBoolean : IEquatable<bool>
  • public bool AccumulateAndGet(bool x, ref ValueFunc accumulator)
  • public bool AccumulateAndGet(bool x, method accumulator)
  • public bool GetAndAccumulate(bool x, ref ValueFunc accumulator)
  • public bool GetAndAccumulate(bool x, method accumulator)
  • public bool GetAndUpdate(ref ValueFunc updater)
  • public bool GetAndUpdate(method updater)
  • public bool UpdateAndGet(ref ValueFunc updater)
  • public bool UpdateAndGet(method updater)
• public static class AtomicDouble
  • public static double AccumulateAndGet(this ref double value, double x, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static double Add(this ref double value, double operand)
  • public static double Add(this double[] array, long index, double operand)
  • public static double AccumulateAndGet(this ref double value, double x, method accumulator)
  • public static double AddAndGet(this ref double value, double operand)
  • 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 double[] array, long index)
  • public static double GetAndAccumulate(this ref double value, double x, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static double GetAndAccumulate(this ref double value, double x, method accumulator)
  • public static double GetAndAdd(this ref double value, double operand)
  • public static double GetAndSet(this double[] array, long index, double update)
  • public static double GetAndUpdate(this ref double value, ref ValueFunc updater)
  • public static double GetAndUpdate(this double[] array, long index, Func<double, double> updater)
  • public static double GetAndUpdate(this double[] array, long index, ref ValueFunc updater)
  • public static double GetAndUpdate(this ref double value, method updater)
  • public static double IncrementAndGet(this double[] array, long index)
  • public static double SetAndGet(this double[] array, long index, double update)
  • public static double UpdateAndGet(this ref double value, ref ValueFunc updater)
  • public static double UpdateAndGet(this double[] array, long index, Func<double, double> updater)
  • public static double UpdateAndGet(this double[] array, long index, ref ValueFunc updater)
  • public static double UpdateAndGet(this ref double value, method updater)
  • public static double VolatileRead(this double[] array, long index)
  • public static void VolatileWrite(this double[] array, long index, double value)
• public struct AtomicEnum<TEnum> : IEquatable<TEnum> where TEnum : struct, Enum
  • public TEnum AccumulateAndGet(TEnum x, ref ValueFunc accumulator)
  • public TEnum AccumulateAndGet(TEnum x, method accumulator)
  • public TEnum GetAndAccumulate(TEnum x, ref ValueFunc accumulator)
  • public TEnum GetAndAccumulate(TEnum x, method accumulator)
  • public TEnum GetAndUpdate(ref ValueFunc updater)
  • public TEnum GetAndUpdate(method updater)
  • public TEnum UpdateAndGet(ref ValueFunc updater)
  • public TEnum UpdateAndGet(method updater)
• public static class AtomicInt32
  • public static int AccumulateAndGet(this ref int value, int x, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static int Add(this ref int value, int operand)
  • public static int Add(this int[] array, long index, int operand)
  • public static int AccumulateAndGet(this ref int value, int x, method accumulator)
  • 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 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 int[] array, long index)
  • public static int GetAndAccumulate(this ref int value, int x, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static int GetAndAccumulate(this ref int value, int x, method accumulator)
  • 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 int GetAndSet(this int[] array, long index, int update)
  • public static int GetAndUpdate(this ref int value, ref ValueFunc updater)
  • public static int GetAndUpdate(this int[] array, long index, Func<int, int> updater)
  • public static int GetAndUpdate(this int[] array, long index, ref ValueFunc updater)
  • public static int GetAndUpdate(this ref int value, method updater)
  • public static int IncrementAndGet(this int[] array, long index)
  • public static int SetAndGet(this int[] array, long index, int update)
  • public static int UpdateAndGet(this ref int value, ref ValueFunc updater)
  • public static int UpdateAndGet(this int[] array, long index, Func<int, int> updater)
  • public static int UpdateAndGet(this int[] array, long index, ref ValueFunc updater)
  • public static int UpdateAndGet(this ref int value, method updater)
  • public static int VolatileRead(this int[] array, long index)
  • 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, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static long Add(this ref long value, long operand)
  • public static long Add(this long[] array, long index, long operand)
  • public static long AccumulateAndGet(this ref long value, long x, method accumulator)
  • 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 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 long[] array, long index)
  • public static long GetAndAccumulate(this ref long value, long x, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static long GetAndAccumulate(this ref long value, long x, method accumulator)
  • 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 long GetAndSet(this long[] array, long index, long update)
  • public static long GetAndUpdate(this ref long value, ref ValueFunc updater)
  • public static long GetAndUpdate(this long[] array, long index, Func<long, long> updater)
  • public static long GetAndUpdate(this long[] array, long index, ref ValueFunc updater)
  • public static long GetAndUpdate(this ref long value, method updater)
  • public static long IncrementAndGet(this long[] array, long index)
  • public static long SetAndGet(this long[] array, long index, long update)
  • public static long UpdateAndGet(this ref long value, ref ValueFunc updater)
  • public static long UpdateAndGet(this long[] array, long index, Func<long, long> updater)
  • public static long UpdateAndGet(this long[] array, long index, ref ValueFunc updater)
  • public static long UpdateAndGet(this ref long value, method updater)
  • public static long VolatileRead(this long[] array, long index)
  • 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, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static IntPtr Add(this ref IntPtr value, IntPtr operand)
  • public static IntPtr AccumulateAndGet(this ref IntPtr value, IntPtr x, method accumulator)
  • 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 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 IntPtr[] array, long index)
  • public static IntPtr GetAndAccumulate(this ref IntPtr value, IntPtr x, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static IntPtr GetAndAccumulate(this ref IntPtr value, IntPtr x, method accumulator)
  • 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 IntPtr GetAndSet(this IntPtr[] array, long index, IntPtr update)
  • public static IntPtr GetAndUpdate(this ref IntPtr value, ref ValueFunc updater)
  • public static IntPtr GetAndUpdate(this IntPtr[] array, long index, Func<IntPtr, IntPtr> updater)
  • public static IntPtr GetAndUpdate(this IntPtr[] array, long index, ref ValueFunc updater)
  • public static IntPtr GetAndUpdate(this ref IntPtr value, method updater)
  • public static IntPtr IncrementAndGet(this IntPtr[] array, long index)
  • public static IntPtr SetAndGet(this IntPtr[] array, long index, IntPtr update)
  • public static IntPtr UpdateAndGet(this ref IntPtr value, ref ValueFunc updater)
  • public static IntPtr UpdateAndGet(this IntPtr[] array, long index, Func<IntPtr, IntPtr> updater)
  • public static IntPtr UpdateAndGet(this IntPtr[] array, long index, ref ValueFunc updater)
  • public static IntPtr UpdateAndGet(this ref IntPtr value, method updater)
  • public static IntPtr VolatileRead(this IntPtr[] array, long index)
  • 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, ref ValueFunc accumulator)
  • public static T AccumulateAndGet<T>(T[] array, long index, T x, Func<T, T, T> accumulator)
  • public static T AccumulateAndGet<T>(T[] array, long index, T x, ref ValueFunc accumulator)
  • public static T AccumulateAndGet<T>(ref T value, T x, method accumulator)
  • public static bool CompareAndSet<T>(T[] array, long index, T expected, T update)
  • public static T CompareExchange<T>(T[] array, long index, T update, T comparand)
  • public static T GetAndAccumulate<T>(ref T value, T x, ref ValueFunc accumulator)
  • public static T GetAndAccumulate<T>(T[] array, long index, T x, Func<T, T, T> accumulator)
  • public static T GetAndAccumulate<T>(T[] array, long index, T x, ref ValueFunc accumulator)
  • public static T GetAndSet<T>(T[] array, long index, T update)
  • public static T GetAndAccumulate<T>(ref T value, T x, method accumulator)
  • public static T GetAndUpdate<T>(ref T value, ref ValueFunc updater)
  • public static T GetAndUpdate<T>(T[] array, long index, Func<T, T> updater)
  • public static T GetAndUpdate<T>(T[] array, long index, ref ValueFunc updater)
  • public static T SetAndGet<T>(T[] array, long index, T update)
  • public static T GetAndUpdate<T>(ref T value, method updater)
  • public static T UpdateAndGet<T>(ref T value, ref ValueFunc updater)
  • public static T UpdateAndGet<T>(T[] array, long index, Func<T, T> updater)
  • public static T UpdateAndGet<T>(T[] array, long index, ref ValueFunc updater)
  • public static T VolatileRead<T>(T[] array, long index)
  • public static void VolatileWrite<T>(T[] array, long index, T element)
  • public static T UpdateAndGet<T>(ref T value, method updater)
• public struct AtomicReference<T> : IEquatable<T>, ISerializable
• public static class AtomicSingle
  • public static float AccumulateAndGet(this ref float value, float x, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static float Add(this ref float value, float operand)
  • public static float Add(this float[] array, long index, float operand)
  • public static float AccumulateAndGet(this ref float value, float x, method accumulator)
  • public static float AddAndGet(this ref float value, float operand)
  • 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 float[] array, long index)
  • public static float GetAndAccumulate(this ref float value, float x, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static float GetAndAccumulate(this ref float value, float x, method accumulator)
  • public static float GetAndAdd(this ref float value, float operand)
  • public static float GetAndSet(this float[] array, long index, float update)
  • public static float GetAndUpdate(this ref float value, ref ValueFunc updater)
  • public static float GetAndUpdate(this float[] array, long index, Func<float, float> updater)
  • public static float GetAndUpdate(this float[] array, long index, ref ValueFunc updater)
  • public static float GetAndUpdate(this ref float value, method updater)
  • public static float IncrementAndGet(this float[] array, long index)
  • public static float SetAndGet(this float[] array, long index, float update)
  • public static float UpdateAndGet(this ref float value, ref ValueFunc updater)
  • public static float UpdateAndGet(this float[] array, long index, Func<float, float> updater)
  • public static float UpdateAndGet(this float[] array, long index, ref ValueFunc updater)
  • public static float UpdateAndGet(this ref float value, method updater)
  • public static float VolatileRead(this float[] array, long index)
  • 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 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 bool CompareAndSet(this ref uint value, uint expected, uint update)
  • public static uint DecrementAndGet(this ref uint value)
  • 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 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 uint GetAndSet(this ref uint value, 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 IncrementAndGet(this ref uint value)
  • public static uint SetAndGet(this ref uint value, 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 VolatileRead(this ref uint value)
  • public static void VolatileWrite(this ref uint value, uint newValue)
• 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 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 bool CompareAndSet(this ref ulong value, ulong expected, ulong update)
  • public static ulong DecrementAndGet(this ref ulong value)
  • 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 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 static ulong GetAndSet(this ref ulong value, 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 IncrementAndGet(this ref ulong value)
  • public static ulong SetAndGet(this ref ulong value, 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 VolatileRead(this ref ulong value)
  • public static void VolatileWrite(this ref ulong value, ulong newValue)
• public struct ReaderWriterSpinLock
  • public void DowngradeFromWriteLock()
  • public bool TryUpgradeToWriteLock()
  • public bool TryUpgradeToWriteLock(TimeSpan timeout, CancellationToken token = default)
  • public void UpgradeToWriteLock()
• public static class ThreadPoolWorkItemFactory
  • public static IThreadPoolWorkItem Create<T>(method workItem, T arg)
  • public static IThreadPoolWorkItem Create<T1, T2>(method workItem, T1 arg1, T2 arg2)
  • public static IThreadPoolWorkItem Create<T1, T2, T3>(method workItem, T1 arg1, T2 arg2, T3 arg3)
• public struct Timeout
  • public static Timeout Infinite { get; }

DotNext.Threading.Tasks

• public static class Continuation
  • public static Task<T> ContinueWithTimeout<T>(this Task<T> task, TimeSpan timeout, CancellationToken token = default)
  • 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, Predicate<AggregateException> filter, TaskScheduler scheduler = null) where TConstant : Constant<T>
• public abstract class Future : IFuture, INotifyCompletion
• public abstract class Future<T> : Future, IConvertible<T> where T : Task
• public interface IFuture : INotifyCompletion
• public static class Synchronization
  • 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)
  • 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)

DotNext.VariantType

• public interface IVariant : IDynamicMetaObjectProvider
• public struct Variant<T1, T2> : IEquatable<Variant<T1, T2>>, IVariant, IDynamicMetaObjectProvider
• public struct Variant<T1, T2, T3> : IVariant, IDynamicMetaObjectProvider, IEquatable<Variant<T1, T2, T3>>
• public struct Variant<T1, T2, T3, T4> : IVariant, IDynamicMetaObjectProvider, IEquatable<Variant<T1, T2, T3, T4>>