DotNext by Roman Sakno

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

---

API Diff between 3.2.1 and 0.5.0

1161 Additions 131 Removals

DotNext

• public struct Activator<T> : ISupplier<T>
• public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : struct
  • public static BitwiseComparer<T> Instance { get; }
  • public static int Compare<TOther>(ref T first, ref TOther second) where TOther : struct
  • public static bool Equals<TOther>(ref T first, ref TOther second) where TOther : struct
  • public static int GetHashCode(ref T value, bool salted = true)
  • public static int GetHashCode(ref T value, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode(ref T value, int hash, method hashFunction, bool salted = true)
• public static class Comparable
• public static class Comparison
  • public static bool Between<T>(this T value, T left, T right, BoundType boundType = 0) where T : IComparable<T>
  • public static T Clamp<T>(this T value, T min, T max) where T : IComparable<T>
• public 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 Func<I, O> AsFunc<I, O>(this Converter<I, O> converter)
  • public static Func<TInput, TOutput> AsFunc<TInput, TOutput>(this Converter<TInput, TOutput> converter)
  • public static Converter<I, O> Identity<I, O>() where I : O
  • public static Converter<TInput, TOutput> Identity<TInput, TOutput>() where TInput : TOutput
  • public static Result<TOutput> TryInvoke<TInput, TOutput>(this Converter<TInput, TOutput> converter, TInput input)
• public static class DelegateHelpers
  • public static D ChangeType<D>(this Delegate d) where D : Delegate
  • public static EventHandler<O> Contravariant<I, O>(this EventHandler<I> handler) where O : I
  • public static D CreateDelegate<D>(this MethodInfo method, object target = null) where D : Delegate
  • public static Action Bind<T>(this Action<T> action, T obj)
  • public static Func<TResult> Bind<T, TResult>(this Func<T, TResult> func, T obj)
  • public static Func<T2, TResult> Bind<T1, T2, TResult>(this Func<T1, T2, TResult> func, T1 obj)
  • public static Action<T2> Bind<T1, T2>(this Action<T1, T2> action, T1 obj)
  • public static Func<T2, T3, TResult> Bind<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> func, T1 obj)
  • public static Action<T2, T3> Bind<T1, T2, T3>(this Action<T1, T2, T3> action, T1 obj)
  • public static Func<T2, T3, T4, TResult> Bind<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> func, T1 obj)
  • public static Action<T2, T3, T4> Bind<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T1 obj)
  • public static Func<T2, T3, T4, T5, TResult> Bind<T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> func, T1 obj)
  • public static Action<T2, T3, T4, T5> Bind<T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action, T1 obj)
  • public static TDelegate ChangeType<TDelegate>(this Delegate d) where TDelegate : Delegate
  • public static EventHandler<T> Contravariant<TBase, T>(this EventHandler<TBase> handler) where T : TBase
  • public static Func<object, TDelegate> CreateClosedDelegateFactory<TDelegate>(Expression<TDelegate> expression) 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 static TDelegate CreateOpenDelegate<TDelegate>(Expression<TDelegate> expression) where TDelegate : Delegate
  • public static Action<T, TValue> CreateOpenDelegate<T, TValue>(Expression<Func<T, TValue>> properyExpr)
  • public static Action<T> Unbind<T>(this Action action)
  • public static Func<T, TResult> Unbind<T, TResult>(this Func<TResult> func)
  • public static Func<T, TArg, TResult> Unbind<T, TArg, TResult>(this Func<TArg, TResult> func)
  • public static Action<T, TArg> Unbind<T, TArg>(this Action<TArg> action)
  • public static Func<T, T1, T2, TResult> Unbind<T, T1, T2, TResult>(this Func<T1, T2, TResult> func)
  • public static Action<T, T1, T2> Unbind<T, T1, T2>(this Action<T1, T2> action)
  • public static Func<T, T1, T2, T3, TResult> Unbind<T, T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> func)
  • public static Action<T, T1, T2, T3> Unbind<T, T1, T2, T3>(this Action<T1, T2, T3> action)
  • public static Func<T, T1, T2, T3, T4, TResult> Unbind<T, T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> func)
  • public static Action<T, T1, T2, T3, T4> Unbind<T, T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action)
  • public static Func<T, T1, T2, T3, T4, T5, TResult> Unbind<T, T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> func)
  • public static Action<T, T1, T2, T3, T4, T5> Unbind<T, T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action)
• 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 Task DisposedTask { get; }
  • public static ValueTask DisposeAsync(IEnumerable<IAsyncDisposable> objects)
  • public static ValueTask DisposeAsync(IAsyncDisposable[] objects)
  • protected ValueTask DisposeAsync(bool continueOnCapturedContext)
  • protected virtual ValueTask DisposeAsyncCore()
  • protected Task<T> GetDisposedTask<T>()
  • protected bool TrySetDisposedException<T>(TaskCompletionSource<T> source)
• public struct Enum<E> : IEquatable<E>, IComparable<E>, IFormattable, IComparable<Enum<E>> where E : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), Enum
• public static class EnumConverter
  • public static bool IsOneOf<T>(this T value, T[] values) where T : struct, Enum
• public static class EqualityComparerBuilder
• public struct EqualityComparerBuilder<T>
  • public void Build(out Func equals, out Func hashCode)
  • public IEqualityComparer<T> Build()
• public static class Func
  • public static Converter<I, O> AsConverter<I, O>(this Func<I, O> function)
  • public static Converter<TInput, TOutput> AsConverter<TInput, TOutput>(this Func<TInput, TOutput> function)
  • public static Func<I, O> Identity<I, O>() where I : O
  • public static Func<T> Constant<T>(T obj)
  • public static Func<TInput, TOutput> Identity<TInput, TOutput>() where TInput : TOutput
  • public static Func<T, bool> IsNotNull<T>()
  • public static Func<T, bool> IsNull<T>()
  • public static Result<TResult> TryInvoke<TResult>(this Func<TResult> function)
  • public static Result<TResult> TryInvoke<T, TResult>(this Func<T, TResult> function, T arg)
  • public static Result<TResult> TryInvoke<T1, T2, TResult>(this Func<T1, T2, TResult> function, T1 arg1, T2 arg2)
  • public static Result<TResult> TryInvoke<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> function, T1 arg1, T2 arg2, T3 arg3)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, TResult>(this Func<T1, T2, T3, T4, T5, T6, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, T7, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
• public interface IOptional
• public sealed delegate ItemAction<I, V> : MulticastDelegate
• public interface IConsumer<T>
  • void Invoke(T arg)
• 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, R1, R2>(this T obj, Func<T, R1> decomposer1, Func<T, R2> decomposer2, out R1 result1, out R2 result2)
  • public static ValueTuple<R1, R2> Decompose<T, R1, R2>(this T obj, Func<T, R1> decomposer1, Func<T, R2> decomposer2)
  • public static T As<T>(this T obj)
• public static class OneDimensionalArray
  • public static int BitwiseHashCode<T>(this T[] array) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static O[] ConvertAll<I, O>(this I[] input, Func<long, I, O> mapper)
  • public static void ForEach<T>(this T[] array, ItemAction<long, T> action)
  • public static int BitwiseHashCode<T>(this T[] array, int hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this T[] array, long hash, Func<long, long, long> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this T[] array, long hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this T[] array, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static T[] Concat<T>(this T[] left, T[] right, long startIndex)
  • public static void ForEach<T>(this T[] array, RefAction<T, long> action)
  • public static void ForEach<T, TArg>(this T[] array, method action, TArg arg)
  • public static T[] RemoveAll<T>(this T[] array, Predicate<T> match, out long count)
  • public static T[] RemoveAll<T>(this T[] array, method match, out long count)
  • public static T[] RemoveAll<T>(this T[] array, Predicate<T> match, Action<T> callback)
  • public static T[] RemoveAll<T>(this T[] array, method match, Action<T> callback)
  • public static T[] RemoveAt<T>(this T[] array, long index)
  • public static bool SequenceEqual<T>(this T[] first, T[] second) where T : IEquatable<T>
  • public static bool SequenceEqual(this object[] first, object[] second)
  • public static bool SequenceEqual(this object[] first, object[] second, bool parallel = false)
  • public static ArraySegment<T> Slice<T>(this T[] input, Range range)
• public static class Optional
  • public static Task<Optional<O>> Convert<I, O>(this Task<Optional<I>> task, Converter<I, O> converter)
  • public static Optional<T> EmptyIfNull<T>(this T value)
  • public static Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<Optional<TInput>> task, Converter<TInput, TOutput> converter)
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T, TException>(this ref Optional optional) where T : struct where TException : Exception
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(this ref Optional optional, Func<Exception> exceptionFactory) where T : struct
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(this ref Optional optional, method exceptionFactory) where T : struct
  • public static Optional<T> None<T>()
  • public static Optional<T> Null<T>()
  • public static Task<T?> OrNull<T>(this Task<Optional<T>> task) where T : struct
  • public static Task<T> OrThrow<T, E>(this Task<Optional<T>> task, Func<E> exceptionFactory) where E : Exception
  • public static Task<T> OrThrow<T, TException>(this Task<Optional<T>> task, Func<TException> exceptionFactory) where TException : Exception
  • public static Optional<T> Some<T>(T value)
• public struct Optional<T> : IEquatable<Optional<T>>, IEquatable<T>, IStructuralEquatable, ISerializable
  • public static Optional<T> Empty { get; }
  • public bool IsPresent { get; }
  • public static Optional<T> None { get; }
  • public bool HasValue { get; }
  • public bool IsNull { get; }
  • public bool IsUndefined { get; }
  • public static bool HasValue(ref T value)
  • public Optional<U> Convert<U>(Converter<T, U> mapper)
  • public Optional<U> Convert<U>(Converter<T, Optional<U>> mapper)
  • public Optional<object> Box()
  • public Optional<TResult> Convert<TResult>(Converter<T, TResult> mapper)
  • public Optional<TResult> Convert<TResult>(method mapper)
  • public Optional<TResult> Convert<TResult>(Converter<T, Optional<TResult>> mapper)
  • public Optional<TResult> Convert<TResult>(method mapper)
  • public bool Equals(ref Optional other)
  • public bool Equals(Optional<T> other)
  • public Optional<T> If(method condition)
  • public T OrInvoke(method defaultFunc)
  • public T OrThrow<E>(Func<E> exceptionFactory) where E : Exception
  • public T OrThrow(Func<Exception> exceptionFactory)
  • public T OrThrow(method exceptionFactory)
  • public bool TryGet(out T value, out bool isNull)
• public static class Predicate
  • public static Predicate<T?> HasValue<T>() where T : struct
  • public static Result<bool> TryInvoke<T>(this Predicate<T> predicate, T obj)
• public static class RandomExtensions
  • public static T Next<T>(this Random random) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static T Next<T>(this RandomNumberGenerator random) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • 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 Range
• public sealed delegate RefAction<T, TArgs> : MulticastDelegate
  • public RefAction(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ref T reference, TArgs args, AsyncCallback callback, object object)
  • public virtual void EndInvoke(ref T reference, IAsyncResult result)
  • public virtual void Invoke(ref T reference, TArgs args)
• public sealed delegate RefFunc<T, TArgs, TResult> : MulticastDelegate
  • public RefFunc(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ref T reference, TArgs args, AsyncCallback callback, object object)
  • public virtual TResult EndInvoke(ref T reference, IAsyncResult result)
  • public virtual TResult Invoke(ref T reference, TArgs args)
• public static class Sequence
• public static class Result
  • public static Result Coalesce<T>(this ref Result first, ref Result second)
  • public static Type GetUnderlyingType(Type resultType)
  • public static bool IsResult(this Type resultType)
  • public static T? OrNull<T>(this ref Result result) where T : struct
• public struct Result<T> : ISerializable
  • public Exception Error { get; }
  • public bool IsSuccessful { get; }
  • public T Value { get; }
  • public Result(T value)
  • public Result(Exception error)
  • public static Result<T> FromOptional(ref Optional optional)
  • public static bool op_BitwiseAnd(ref Result left, ref Result right)
  • public static T op_Explicit(ref Result result)
  • public static Result<T> op_Explicit(ref Optional optional)
  • public static bool op_False(ref Result result)
  • public static Optional<T> op_Implicit(ref Result result)
  • public static Result<T> op_Implicit(T result)
  • public static bool op_True(ref Result result)
  • public Result<object> Box()
  • public Result<TResult> Convert<TResult>(Converter<T, TResult> converter)
  • public Result<TResult> 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<Exception, T> defaultFunc)
  • public T OrInvoke(method defaultFunc)
  • public bool TryGet(out T value)
  • public Optional<T> TryGet()
• 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 Span<byte> AsBytes<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static Span<byte> AsBytes<T>(T* pointer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static ReadOnlySpan<byte> AsReadOnlyBytes<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static int BitwiseCompare<T>(this Span<T> first, Span<T> second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseCompare<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static bool BitwiseEquals<T>(this Span<T> first, Span<T> second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static bool BitwiseEquals<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this Span<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this ReadOnlySpan<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this Span<T> span, int hash, Func<int, int, int> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this Span<T> span, int hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this ReadOnlySpan<T> span, int hash, Func<int, int, int> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this ReadOnlySpan<T> span, int hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this Span<T> span, long hash, Func<long, long, long> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this Span<T> span, long hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this ReadOnlySpan<T> span, long hash, Func<long, long, long> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this ReadOnlySpan<T> span, long hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this Span<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this ReadOnlySpan<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static MemoryOwner<T> Concat<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second, MemoryAllocator<T> allocator = null)
  • public static MemoryOwner<T> Concat<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second, ReadOnlySpan<T> third, MemoryAllocator<T> allocator = null)
  • public static MemoryOwner<T> Copy<T>(this ReadOnlySpan<T> span, MemoryAllocator<T> allocator = null)
  • public static void CopyTo<T>(this ReadOnlySpan<T> source, Span<T> destination, out int writtenCount)
  • public static void CopyTo<T>(this Span<T> source, Span<T> destination, out int writtenCount)
  • public static void ForEach<T>(this Span<T> span, RefAction<T, int> action)
  • public static void ForEach<T, TArg>(this Span<T> span, method action, TArg arg)
  • public static int FromHex(this ReadOnlySpan<char> chars, Span<byte> output)
  • public static byte[] FromHex(this ReadOnlySpan<char> chars)
  • public static int IndexOf<T>(this ReadOnlySpan<T> span, T value, int startIndex, Func<T, T, bool> comparer)
  • public static int IndexOf<T>(this ReadOnlySpan<T> span, T value, int startIndex, method comparer)
  • public static void Sort<T>(this Span<T> span, IComparer<T> comparison = null)
  • public static void Sort<T>(this Span<T> span, Comparison<T> comparison)
  • public static void Sort<T>(this Span<T> span, method comparison)
  • public static int ToHex(this ReadOnlySpan<byte> bytes, Span<char> output, bool lowercased = false)
  • public static string ToHex(this ReadOnlySpan<byte> bytes, bool lowercased = false)
  • public static Span<T> TrimLength<T>(this Span<T> span, int maxLength)
  • public static ReadOnlySpan<T> TrimLength<T>(this ReadOnlySpan<T> span, int maxLength)
• public static class StringExtensions
  • public static MemoryTemplate<char> AsTemplate(this string template, string placeholder)
  • public static MemoryTemplate<char> AsTemplate(this string template, char placeholder)
  • public static bool IsEqualIgnoreCase(this string strA, string strB)
  • public static bool IsNullOrEmpty(this StringBuilder builder)
  • public static string Substring(this string str, Range range)
• 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 object[] ToArray<T>(this T tuple) where T : ITuple
• public struct UserDataSlot<TValue> : IEquatable<UserDataSlot<TValue>>
  • public static UserDataSlot<V> Allocate()
  • public static bool op_Equality(UserDataSlot<V> first, UserDataSlot<V> second)
  • public static bool op_Inequality(UserDataSlot<V> first, UserDataSlot<V> second)
  • public bool Equals(UserDataSlot<V> other)
  • public static UserDataSlot<TValue> Allocate()
  • public static bool op_Equality(UserDataSlot<TValue> first, UserDataSlot<TValue> second)
  • public static bool op_Inequality(UserDataSlot<TValue> first, UserDataSlot<TValue> second)
  • public bool Equals(UserDataSlot<TValue> other)
• public struct UserDataStorage
  • public interface IContainer
  • public V Get<V>(UserDataSlot<V> slot, V defaultValue = null)
  • public V GetOrSet<V>(UserDataSlot<V> slot)
  • public V GetOrSet<V>(UserDataSlot<V> slot, Func<V> valueFactory)
  • public bool Remove<V>(UserDataSlot<V> slot)
  • public bool Remove<V>(UserDataSlot<V> slot, out V userData)
  • public void Set<V>(UserDataSlot<V> slot, V userData)
  • public bool TryGet<V>(UserDataSlot<V> slot, out V userData)
  • public void CopyTo(object obj)
  • public TValue Get<TValue>(UserDataSlot<TValue> slot, TValue defaultValue)
  • public TValue Get<TValue>(UserDataSlot<TValue> slot)
  • public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot)
  • public TBase GetOrSet<TBase, T>(UserDataSlot<TBase> slot) where T : TBase
  • public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot, Func<TValue> valueFactory)
  • public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot, method valueFactory)
  • public TValue GetOrSet<T, TValue>(UserDataSlot<TValue> slot, T arg, Func<T, TValue> valueFactory)
  • public TValue GetOrSet<T, TValue>(UserDataSlot<TValue> slot, T arg, method valueFactory)
  • public TValue GetOrSet<T1, T2, TValue>(UserDataSlot<TValue> slot, T1 arg1, T2 arg2, Func<T1, T2, TValue> 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 bool Remove<TValue>(UserDataSlot<TValue> slot)
  • public bool Remove<TValue>(UserDataSlot<TValue> slot, out TValue userData)
  • public void Set<TValue>(UserDataSlot<TValue> slot, TValue userData)
  • public bool TryGet<TValue>(UserDataSlot<TValue> slot, out TValue userData)
• public sealed class ValueType<T> : StrongBox<T> where T : struct
• public static class ValueTypeExtensions
  • public static void BitCast<FROM, TO>(this FROM input, out TO output) where FROM : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where TO : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static TO BitCast<FROM, TO>(this FROM input) where FROM : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where TO : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static ValueType<T> Box<T>(this T value) where T : struct
  • public static IntPtr Add(this IntPtr x, IntPtr y)
  • public static UIntPtr Add(this UIntPtr x, UIntPtr y)
  • public static IntPtr AddChecked(this IntPtr x, IntPtr y)
  • public static UIntPtr AddChecked(this UIntPtr x, UIntPtr y)
  • public static UIntPtr And(this UIntPtr x, UIntPtr y)
  • public static IntPtr And(this IntPtr x, IntPtr y)
  • public static IntPtr Decrement(this IntPtr value)
  • public static UIntPtr Decrement(this UIntPtr value)
  • public static IntPtr Divide(this IntPtr x, IntPtr y)
  • public static UIntPtr Divide(this UIntPtr x, UIntPtr y)
  • public static bool GreaterThan(this IntPtr value, IntPtr comparand)
  • public static bool GreaterThan(this UIntPtr value, UIntPtr comparand)
  • public static bool GreaterThanOrEqual(this IntPtr value, IntPtr comparand)
  • public static bool GreaterThanOrEqual(this UIntPtr value, UIntPtr comparand)
  • public static IntPtr Increment(this IntPtr value)
  • public static UIntPtr Increment(this UIntPtr value)
  • public static IntPtr LeftShift(this IntPtr value, int bits)
  • public static UIntPtr LeftShift(this UIntPtr value, int bits)
  • public static bool LessThan(this IntPtr value, IntPtr comparand)
  • public static bool LessThan(this UIntPtr value, UIntPtr comparand)
  • public static bool LessThanOrEqual(this IntPtr value, IntPtr comparand)
  • public static bool LessThanOrEqual(this UIntPtr value, UIntPtr comparand)
  • public static IntPtr Multiply(this IntPtr x, IntPtr y)
  • public static UIntPtr Multiply(this UIntPtr x, UIntPtr y)
  • public static IntPtr MultiplyChecked(this IntPtr x, IntPtr y)
  • public static UIntPtr MultiplyChecked(this UIntPtr x, UIntPtr y)
  • public static IntPtr Negate(this IntPtr value)
  • public static IntPtr OnesComplement(this IntPtr value)
  • public static UIntPtr OnesComplement(this UIntPtr value)
  • public static IntPtr Or(this IntPtr x, IntPtr y)
  • public static UIntPtr Or(this UIntPtr x, UIntPtr y)
  • public static IntPtr Remainder(this IntPtr x, IntPtr y)
  • public static UIntPtr Remainder(this UIntPtr x, UIntPtr y)
  • public static IntPtr RightShift(this IntPtr value, int bits)
  • public static UIntPtr RightShift(this UIntPtr value, int bits)
  • public static IntPtr Subtract(this IntPtr x, IntPtr y)
  • public static UIntPtr Subtract(this UIntPtr x, UIntPtr y)
  • public static IntPtr SubtractChecked(this IntPtr x, IntPtr y)
  • public static UIntPtr SubtractChecked(this UIntPtr x, UIntPtr y)
  • public static bool ToBoolean(this int value)
  • public static byte ToByte(this bool value)
  • public static int ToInt32(this bool value)
  • public static IntPtr ToIntPtr(this UIntPtr value)
  • public static IntPtr ToIntPtrChecked(this UIntPtr value)
  • public static UIntPtr ToUIntPtr(this IntPtr value)
  • public static UIntPtr ToUIntPtrChecked(this IntPtr value)
  • public static int Truncate(this long value)
  • public static bool TryGetValue<T>(this T? nullable, out T value) where T : struct
  • public static IntPtr Xor(this IntPtr x, IntPtr y)
  • public static UIntPtr Xor(this UIntPtr x, UIntPtr y)

DotNext.Buffers

• public struct ArrayRental<T> : IDisposable
• 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 bool TryRead<T>(this ref SpanReader reader, out T result) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static bool TryWrite<T>(this ref SpanWriter writer, ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Write(this ref BufferWriterSlim writer, StringBuilder input)
  • public static void Write<T>(this IBufferWriter<T> writer, T value)
  • public static void Write<T>(this IBufferWriter<T> writer, ref ReadOnlySequence value)
  • public static void Write(this IBufferWriter<char> writer, StringBuilder input)
  • public static void Write<T>(this ref SpanWriter writer, ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Write(this ref SpanWriter writer, StringBuilder input)
  • public static void WriteDouble(this ref BufferWriterSlim builder, double value, bool isLittleEndian)
  • public static void WriteDouble(this ref SpanWriter writer, double value, bool isLittleEndian)
  • public static void WriteInt16(this ref BufferWriterSlim builder, short value, bool isLittleEndian)
  • public static void WriteInt16(this ref SpanWriter writer, short value, bool isLittleEndian)
  • public static void WriteInt32(this ref BufferWriterSlim builder, int value, bool isLittleEndian)
  • public static void WriteInt32(this ref SpanWriter writer, int value, bool isLittleEndian)
  • public static void WriteInt64(this ref BufferWriterSlim builder, long value, bool isLittleEndian)
  • public static void WriteInt64(this ref SpanWriter writer, long value, bool isLittleEndian)
  • public static void WriteSingle(this ref BufferWriterSlim builder, float value, bool isLittleEndian)
  • public static void WriteSingle(this ref SpanWriter writer, float value, bool isLittleEndian)
  • public static void WriteUInt16(this ref BufferWriterSlim builder, ushort value, bool isLittleEndian)
  • public static void WriteUInt16(this ref SpanWriter writer, ushort value, bool isLittleEndian)
  • public static void WriteUInt32(this ref BufferWriterSlim builder, uint value, bool isLittleEndian)
  • public static void WriteUInt32(this ref SpanWriter writer, uint value, bool isLittleEndian)
  • public static void WriteUInt64(this ref BufferWriterSlim builder, ulong value, bool isLittleEndian)
  • public static void WriteUInt64(this ref SpanWriter writer, ulong value, bool isLittleEndian)
• public abstract class BufferWriter<T> : Disposable, IBufferWriter<T>, ISupplier<ReadOnlyMemory<T>>, IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IGrowableBuffer<T>, IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IDisposable
  • public 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 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 BufferWriterSlim<T>
  • public int Capacity { get; }
  • public int FreeCapacity { get; }
  • public ref T this[int index] { get; }
  • public int WrittenCount { get; }
  • public ReadOnlySpan<T> WrittenSpan { get; }
  • public BufferWriterSlim(Span<T> buffer, MemoryAllocator<T> allocator = null)
  • public BufferWriterSlim(int initialCapacity, MemoryAllocator<T> allocator = null)
  • public void Add(T item)
  • public void Advance(int count)
  • public void Clear(bool reuseBuffer)
  • public void Dispose()
  • public Span<T> GetSpan(int sizeHint = 0)
  • public bool TryDetachBuffer(out MemoryOwner owner)
  • public void Write(ReadOnlySpan<T> input)
• 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 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 MemoryAllocator<T> CreateArrayAllocator<T>()
  • public static MemoryOwner<T> Invoke<T>(this MemoryAllocator<T> allocator, int length, bool exactSize)
  • public static MemoryAllocator<T> ToAllocator<T>(this ArrayPool<T> pool)
  • public static MemoryAllocator<T> ToAllocator<T>(this MemoryPool<T> pool)
  • public static MemoryAllocator<T> ToAllocator<T>(this Func<int, IMemoryOwner<T>> provider)
• public sealed delegate MemoryAllocator<T> : MulticastDelegate
  • public MemoryAllocator(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(int length, AsyncCallback callback, object object)
  • public virtual MemoryOwner<T> EndInvoke(IAsyncResult result)
  • public virtual MemoryOwner<T> Invoke(int length)
• public struct MemoryOwner<T> : IMemoryOwner<T>, IDisposable, ISupplier<Memory<T>>
  • public bool IsEmpty { get; }
  • public ref T this[IntPtr index] { get; }
  • public ref T this[int index] { get; }
  • public int Length { get; }
  • public Memory<T> Memory { get; }
  • public MemoryOwner(ArrayPool<T> pool, int length)
  • public MemoryOwner(MemoryPool<T> pool, int length = -1)
  • public MemoryOwner(Func<int, IMemoryOwner<T>> provider, int length)
  • public MemoryOwner(Func<IMemoryOwner<T>> provider)
  • public MemoryOwner(T[] array, int length)
  • public MemoryOwner(T[] array)
  • public static MemoryOwner<T> Create<TArg>(method provider, int length, TArg arg, bool exactSize = true)
  • public void Dispose()
  • public bool TryGetArray(out ArraySegment segment)
  • public bool TryResize(int newLength)
• public struct MemoryRental<T>
  • public static int StackallocThreshold { get; }
  • public bool IsEmpty { get; }
  • public ref T this[int index] { get; }
  • public int Length { get; }
  • public Span<T> Span { get; }
  • public MemoryRental(Span<T> span)
  • public MemoryRental(Span<T> span, int length)
  • public MemoryRental(MemoryPool<T> pool, int minBufferSize, bool exactSize = true)
  • public MemoryRental(MemoryPool<T> pool)
  • public MemoryRental(int minBufferSize, bool exactSize = true)
  • public static MemoryRental<T> op_Implicit(Span<T> span)
  • public void Dispose()
  • public ref T GetPinnableReference()
• public static class MemoryTemplate
  • public static void Render(this ref MemoryTemplate template, StringBuilder output, string[] replacement)
  • public static string Render(this ref MemoryTemplate template, string[] replacement)
  • public static void Render(this ref MemoryTemplate template, TextWriter output, string[] replacement)
• public struct MemoryTemplate<T> where T : IEquatable<T>
  • public ReadOnlyMemory<T> Value { get; }
  • public MemoryTemplate(ReadOnlyMemory<T> template, ReadOnlySpan<T> placeholder)
  • public void Render<TConsumer>(TConsumer consumer) where TConsumer : IReadOnlySpanConsumer<T>, IConsumer<int>
  • public void Render<TWriter>(TWriter output, Action<int, TWriter> rewriter) where TWriter : IBufferWriter<T>
  • public void Render<TArg>(TArg arg, Action<int, TArg> rewriter, ReadOnlySpanAction<T, TArg> output)
• public sealed class PooledArrayBufferWriter<T> : BufferWriter<T>, ISupplier<ArraySegment<T>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
  • public ref T this[int index] { get; }
  • public ref T this[long index] { get; }
  • public ArraySegment<T> WrittenArray { get; }
  • public PooledArrayBufferWriter(ArrayPool<T> pool, int initialCapacity)
  • public PooledArrayBufferWriter(ArrayPool<T> pool)
  • public PooledArrayBufferWriter()
  • public PooledArrayBufferWriter(int initialCapacity)
  • public ArraySegment<T> GetArray(int sizeHint = 0)
  • public void Insert(int index, ReadOnlySpan<T> items)
  • public void Overwrite(int index, ReadOnlySpan<T> items)
  • public void RemoveFirst(int count)
  • public void RemoveLast(int count)
• public sealed class PooledBufferWriter<T> : BufferWriter<T>, IMemoryOwner<T>, IDisposable
  • public PooledBufferWriter(MemoryAllocator<T> allocator, int initialCapacity)
  • public PooledBufferWriter(MemoryAllocator<T> allocator = null)
• public struct 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 int ConsumedCount { get; }
  • public ReadOnlySpan<T> ConsumedSpan { get; }
  • public T& modreq(System.Runtime.InteropServices.InAttribute) Current { get; }
  • public int RemainingCount { get; }
  • public ReadOnlySpan<T> RemainingSpan { get; }
  • public ReadOnlySpan<T> Span { get; }
  • public SpanReader(ReadOnlySpan<T> span)
  • public SpanReader(ref T reference, int length)
  • public void Advance(int count)
  • public int Read(Span<T> output)
  • public T Read()
  • public ReadOnlySpan<T> Read(int count)
  • public TResult Read<TResult>(method reader, int count)
  • public ReadOnlySpan<T> ReadToEnd()
  • public void Reset()
  • public void Rewind(int count)
  • public bool TryRead(Span<T> output)
  • public bool TryRead(int count, out ReadOnlySpan result)
  • public bool TryRead(out T result)
  • public bool TryRead<TResult>(method reader, int count, out TResult result)
• public struct SpanWriter<T>
  • public ref T Current { get; }
  • public int FreeCapacity { get; }
  • public Span<T> RemainingSpan { get; }
  • public Span<T> Span { get; }
  • public int WrittenCount { get; }
  • public Span<T> WrittenSpan { get; }
  • public SpanWriter(Span<T> span)
  • public SpanWriter(ref T reference, int length)
  • public void Add(T item)
  • public void Advance(int count)
  • public void Reset()
  • public void Rewind(int count)
  • public Span<T> Slide(int count)
  • public bool TryAdd(T item)
  • public bool TrySlide(int count, out Span segment)
  • public bool TryWrite(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 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.Concurrent

• public class CopyOnWriteList<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IList<T>, ICollection<T>, ICloneable

DotNext.Collections.Generic

• public static class Collection
  • public static ReadOnlyCollectionView<T> AsReadOnlyView<T>(this ICollection<T> collection)
  • public static ReadOnlyCollectionView<I, O> Convert<I, O>(this IReadOnlyCollection<I> collection, Converter<I, O> converter)
  • public static ReadOnlyCollectionView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyCollection<TInput> collection, Converter<TInput, TOutput> converter)
• public static class Dictionary
  • public static ReadOnlyDictionaryView<K, V> AsReadOnlyView<K, V>(this IDictionary<K, V> dictionary)
  • public static ReadOnlyDictionaryView<K, V, T> Convert<K, V, T>(this IReadOnlyDictionary<K, V> dictionary, Converter<V, T> mapper)
  • public static Optional<T> ConvertValue<K, V, T>(this IDictionary<K, V> dictionary, K key, Converter<V, T> mapper)
  • public static bool ConvertValue<K, V, T>(this IDictionary<K, V> dictionary, K key, Converter<V, T> mapper, out T value)
  • public static void Deconstruct<K, V>(this KeyValuePair<K, V> pair, out K key, out V value)
  • public static void ForEach<K, V>(this IDictionary<K, V> dictionary, Action<K, V> action)
  • public static V GetOrAdd<K, V>(this Dictionary<K, V> dictionary, K key, V value)
  • public static V GetOrAdd<K, V>(this Dictionary<K, V> dictionary, K key, Func<K, V> valueFactory)
  • public static V GetOrInvoke<K, V>(this IDictionary<K, V> dictionary, K key, Func<V> defaultValue)
  • public static Func<K, V> IndexerGetter<K, V>(this IReadOnlyDictionary<K, V> dictionary)
  • public static Func<K, V> IndexerGetter<K, V>(this IDictionary<K, V> dictionary)
  • public static Action<K, V> IndexerSetter<K, V>(this IDictionary<K, V> dictionary)
  • public static ReadOnlyDictionaryView<TKey, TValue, TResult> ConvertValues<TKey, TValue, TResult>(this IReadOnlyDictionary<TKey, TValue> dictionary, Converter<TValue, TResult> mapper)
  • public static void ForEach<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, Action<TKey, TValue> action)
  • public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key)
  • public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key, TValue value)
  • public static TValue GetOrAdd<TKey, TValue, TFactory>(this Dictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TValue> valueFactory) where TFactory : struct, ISupplier<TKey, TValue>
  • 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 TValue GetOrInvoke<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, Func<TValue> defaultValue)
  • public static Func<TKey, TValue> IndexerGetter<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary)
  • public static Func<TKey, TValue> IndexerGetter<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
  • public static Action<TKey, TValue> IndexerSetter<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
  • public static Func<IEnumerable<TKey>> KeysGetter<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary)
  • public static Func<ICollection<TKey>> KeysGetter<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
  • public static Optional<TValue> TryGetValue<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
  • public static Optional<TValue> TryGetValue<TKey, TValue>(IReadOnlyDictionary<TKey, TValue> dictionary, TKey key)
  • public static Optional<TValue> TryRemove<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
  • public static Func<IEnumerable<TValue>> ValuesGetter<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary)
  • public static Func<ICollection<TValue>> ValuesGetter<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
• public static class List
  • public static ReadOnlyListView<T> AsReadOnlyView<T>(this IList<T> list)
  • public static ReadOnlyListView<I, O> Convert<I, O>(this IReadOnlyList<I> list, Converter<I, O> converter)
  • public static ReadOnlyListView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyList<TInput> list, Converter<TInput, TOutput> converter)
  • public static void Insert<T>(this IList<T> list, Index index, T item)
  • 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, Comparison<T> comparer)
  • public static int InsertOrdered<T>(this IList<T> list, T item, method comparer)
  • public static void RemoveAt<T>(this IList<T> list, Index index)
  • public static void RemoveRange<T>(this List<T> list, Range range)
  • public static O[] ToArray<I, O>(this IList<I> input, Converter<I, O> mapper)
  • public static O[] ToArray<I, O>(this IList<I> input, Func<int, I, O> mapper)
  • public static ListSegment<T> Slice<T>(this IList<T> list, Range range)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, Converter<TInput, TOutput> mapper)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, method mapper)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, Func<int, TInput, TOutput> mapper)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, method mapper)
• public struct ReadOnlyCollectionView<T> : IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, IEquatable<ReadOnlyCollectionView<T>>
• public struct ListSegment<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyList<T>, IReadOnlyCollection<T>
  • public int Count { get; }
  • public T this[int index] { get; set; }
  • public ListSegment(IList<T> list, Range range)
  • public bool Contains(T item)
  • public void CopyTo(T[] array, int arrayIndex)
  • public IEnumerator<T> GetEnumerator()
  • public int IndexOf(T item)
  • public bool TryGetSpan(out Span span)
• public struct ReadOnlyCollectionView<TInput, TOutput> : IReadOnlyCollection<TOutput>, IEnumerable<TOutput>, IEnumerable, IEquatable<ReadOnlyCollectionView<TInput, TOutput>>
  • public ReadOnlyCollectionView(IReadOnlyCollection<I> collection, Converter<I, O> mapper)
  • public static bool op_Equality(ReadOnlyCollectionView<I, O> first, ReadOnlyCollectionView<I, O> second)
  • public static bool op_Inequality(ReadOnlyCollectionView<I, O> first, ReadOnlyCollectionView<I, O> second)
  • public bool Equals(ReadOnlyCollectionView<I, O> other)
  • public IEnumerator<O> GetEnumerator()
  • 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 bool Equals(ReadOnlyCollectionView<TInput, TOutput> other)
  • public IEnumerator<TOutput> GetEnumerator()
• public struct ReadOnlyDictionaryView<K, V> : IReadOnlyDictionary<K, V>, IEnumerable<KeyValuePair<K, V>>, IEnumerable, IReadOnlyCollection<KeyValuePair<K, V>>, IEquatable<ReadOnlyDictionaryView<K, V>>
• public struct ReadOnlyDictionaryView<TKey, TInput, TOutput> : IReadOnlyDictionary<TKey, TOutput>, IEnumerable<KeyValuePair<TKey, TOutput>>, IEnumerable, IReadOnlyCollection<KeyValuePair<TKey, TOutput>>, IEquatable<ReadOnlyDictionaryView<TKey, TInput, TOutput>>
  • public O this[K key] { get; }
  • public IEnumerable<K> Keys { get; }
  • public IEnumerable<O> Values { get; }
  • public ReadOnlyDictionaryView(IReadOnlyDictionary<K, I> dictionary, Converter<I, O> mapper)
  • public static bool op_Equality(ReadOnlyDictionaryView<K, I, O> first, ReadOnlyDictionaryView<K, I, O> second)
  • public static bool op_Inequality(ReadOnlyDictionaryView<K, I, O> first, ReadOnlyDictionaryView<K, I, O> second)
  • public bool ContainsKey(K key)
  • public bool Equals(ReadOnlyDictionaryView<K, I, O> other)
  • public IEnumerator<KeyValuePair<K, O>> GetEnumerator()
  • public bool TryGetValue(K key, out O value)
  • public TOutput this[TKey key] { get; }
  • public IEnumerable<TKey> Keys { get; }
  • public IEnumerable<TOutput> Values { get; }
  • 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 bool ContainsKey(TKey key)
  • public bool Equals(ReadOnlyDictionaryView<TKey, TInput, TOutput> other)
  • public IEnumerator<KeyValuePair<TKey, TOutput>> GetEnumerator()
  • public bool TryGetValue(TKey key, out TOutput value)
• public struct ReadOnlyListView<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IEquatable<ReadOnlyListView<T>>
• public struct ReadOnlyListView<TInput, TOutput> : IReadOnlyList<TOutput>, IEnumerable<TOutput>, IEnumerable, IReadOnlyCollection<TOutput>, IEquatable<ReadOnlyListView<TInput, TOutput>>
  • public O this[int index] { get; }
  • public ReadOnlyListView(IReadOnlyList<I> list, Converter<I, O> mapper)
  • public static bool op_Equality(ReadOnlyListView<I, O> first, ReadOnlyListView<I, O> second)
  • public static bool op_Inequality(ReadOnlyListView<I, O> first, ReadOnlyListView<I, O> second)
  • public bool Equals(ReadOnlyListView<I, O> other)
  • public IEnumerator<O> GetEnumerator()
  • public TOutput this[int index] { get; }
  • 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 bool Equals(ReadOnlyListView<TInput, TOutput> other)
  • public IEnumerator<TOutput> GetEnumerator()
• public static class Stack
• public static class Sequence
  • public struct AsyncGenerator<T> : IAsyncEnumerable<T>
  • public struct ConsumingEnumerable<T> : IEnumerable<T>, IEnumerable
  • public struct Generator<T>
  • public struct LimitedEnumerator<T> : IEnumerator<T>, IEnumerator, IDisposable
  • public static IEnumerable<T> Append<T>(this IEnumerable<T> collection, T[] items)
  • public static bool ElementAt<T>(this IEnumerable<T> collection, int index, out T element)
  • public static ValueTask<Optional<T>> ElementAtAsync<T>(this IAsyncEnumerable<T> collection, int index, CancellationToken token = default)
  • public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq)
  • public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq, Predicate<T> filter)
  • public static ValueTask<Optional<T>> FirstOrEmptyAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default)
  • public static ValueTask<Optional<T>> FirstOrEmptyAsync<T>(this IAsyncEnumerable<T> seq, Predicate<T> filter, CancellationToken token = default)
  • public static T? FirstOrNull<T>(this IEnumerable<T> seq) where T : struct
  • public static ValueTask<T?> FirstOrNullAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default) where T : struct
  • public static void ForEach<T>(this IEnumerable<T> collection, Action<T> action)
  • public static ValueTask ForEachAsync<T>(this IAsyncEnumerable<T> collection, Action<T> action, CancellationToken token = default)
  • public static ValueTask ForEachAsync<T>(this IAsyncEnumerable<T> collection, Func<T, CancellationToken, ValueTask> action, CancellationToken token = default)
  • public static ValueTask ForEachAsync<T>(this IEnumerable<T> collection, Func<T, CancellationToken, ValueTask> action, CancellationToken token = default)
  • public static IAsyncEnumerator<T> GetAsyncEnumerator<T>(this IEnumerable<T> enumerable, CancellationToken token = default)
  • public static ConsumingEnumerable<T> GetConsumer<T>(this IProducerConsumerCollection<T> collection)
  • public static LimitedEnumerator<T> Limit<T>(this IEnumerator<T> enumerator, int count, bool leaveOpen = false)
  • public static IEnumerable<T> Prepend<T>(this IEnumerable<T> collection, T[] items)
  • public static int SequenceHashCode(this IEnumerable<object> sequence, bool salted = true)
  • public static IEnumerable<T> Singleton<T>(T item)
  • public static bool Skip<T>(this IEnumerator<T> enumerator, int count)
  • public static bool Skip<TEnumerator, T>(this ref TEnumerator enumerator, int count) where TEnumerator : struct, IEnumerator<T>
  • public static ValueTask<bool> SkipAsync<T>(this IAsyncEnumerator<T> enumerator, int count)
  • public static IAsyncEnumerable<T> SkipNulls<T>(this IAsyncEnumerable<T> collection)
  • public static IEnumerable<T> SkipNulls<T>(this IEnumerable<T> collection)
  • public static Task<T[]> ToArrayAsync<T>(this IAsyncEnumerable<T> collection, int initialCapacity = 10, MemoryAllocator<T> allocator = null, CancellationToken token = default)
  • public static IAsyncEnumerable<T> ToAsyncEnumerable<T>(this IEnumerable<T> enumerable)
  • public static AsyncGenerator<T> ToAsyncEnumerable<T>(this Func<CancellationToken, ValueTask<Optional<T>>> generator)
  • public static Generator<T> ToEnumerable<T>(this Func<Optional<T>> generator)
  • public static IEnumerator<T> ToEnumerator<T>(ReadOnlyMemory<T> memory)
  • public static string ToString<T>(this IEnumerable<T> collection, string delimiter, string ifEmpty = "")

DotNext.Diagnostics

• public struct Timestamp : IEquatable<Timestamp>, IComparable<Timestamp>
  • public static Timestamp Current { get; }
  • public TimeSpan Elapsed { get; }
  • public TimeSpan Value { get; }
  • public static bool op_Equality(Timestamp first, Timestamp second)
  • public static bool op_GreaterThan(Timestamp first, Timestamp second)
  • public static bool op_GreaterThanOrEqual(Timestamp first, Timestamp second)
  • public static TimeSpan op_Implicit(Timestamp stamp)
  • public static bool op_Inequality(Timestamp first, Timestamp second)
  • public static bool op_LessThan(Timestamp first, Timestamp second)
  • public static bool op_LessThanOrEqual(Timestamp first, Timestamp second)
  • public static Timestamp VolatileRead(ref Timestamp location)
  • public static void VolatileWrite(ref Timestamp location, Timestamp newValue)
  • public int CompareTo(Timestamp other)
  • public bool Equals(Timestamp other)

DotNext.Generic

• public abstract class Constant<T> : ISupplier<T>
  • public T Value { get; }
  • public static T Of<G>(bool intern = true) where G : Constant<T>
• public abstract class IntConst : Constant<int>
• public abstract class LongConst : Constant<long>
• public sealed class DefaultConst<T> : Constant<T>
  • public DefaultConst()
• public abstract class Int32Const : Constant<int>
  • public sealed class Max : Int32Const
  • public sealed class Min : Int32Const
  • public sealed class Zero : Int32Const
  • protected Int32Const(int value)
• public abstract class Int64Const : Constant<long>
  • public sealed class Max : Int64Const
  • public sealed class Min : Int64Const
  • public sealed class Zero : Int64Const
  • protected Int64Const(long value)

DotNext.IO

• public interface IFlushable
  • void DiscoverFlushMethods<T>(T obj, ref Action flush, ref Func flushAsync)
  • void Flush()
  • Task FlushAsync(CancellationToken token = default)
• 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 ArraySegment<byte> segment, bool writable = false)
  • public static Stream AsStream(this ReadOnlySequence<byte> sequence)
  • public static Stream AsStream(this ReadOnlyMemory<byte> memory)
  • public static Stream AsStream<TArg>(this ReadOnlySpanAction<byte, TArg> writer, TArg arg, Action<TArg> flush = null, Func<TArg, CancellationToken, Task> flushAsync = null)
  • public static Stream AsStream<TWriter>(this TWriter writer, Action<TWriter> flush = null, Func<TWriter, CancellationToken, Task> flushAsync = null) where TWriter : IBufferWriter<byte>
  • public static Stream AsStream(this SparseBufferWriter<byte> writer, bool readable)
  • public static Stream AsStream<TArg>(this Func<ReadOnlyMemory<byte>, TArg, CancellationToken, ValueTask> writer, TArg arg, Action<TArg> flush = null, Func<TArg, CancellationToken, Task> flushAsync = null)
  • 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.NetworkInformation

• public class MtuDiscovery : Ping
  • public MtuDiscovery()
  • public int? Discover(IPAddress address, int timeout, MtuDiscoveryOptions options, CancellationToken token = default)
  • public Task<int?> DiscoverAsync(IPAddress address, int timeout, MtuDiscoveryOptions options, CancellationToken token = default)
• public class MtuDiscoveryOptions : PingOptions
  • public int MaxMtuSize { get; set; }
  • public int MinMtuSize { get; set; }
  • public MtuDiscoveryOptions(byte ttl = 64, int minMtuSize = 60, int maxMtuSize = 65500)

DotNext.Reflection

• public static class CollectionType
  • public static Type GetImplementedCollection(this Type type)
• public static class Conversion<I, O>
• public static class CustomAttribute
  • public static bool IsDefined<TAttribute>(this ICustomAttributeProvider member, bool inherit = false) where TAttribute : Attribute
• public static class DisposableType
  • public static MethodInfo GetDisposeAsyncMethod(this Type type)
• public static class Method
• 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 MethodExtensions
  • public static Type[] GetParameterTypes(this MethodBase method)
  • public static bool SignatureEquals(this MethodBase method, Type[] parameters)
  • public static bool SignatureEquals(this MethodBase method, MethodBase other, bool respectCallingConvention = false)
  • public static bool SignatureEquals(this MethodInfo method, MethodInfo other, bool respectCallingConvention = false)
  • public static Result<object> TryInvoke(this MethodBase method, object obj, object[] args)
• public static class TaskType
  • public static Type MakeTaskType(this Type taskResult, bool valueTask)
• public static class TypeExtensions
  • public static MethodInfo Devirtualize(this Type type, MethodInfo abstractMethod)
  • public static MethodInfo GetMethod(this Type type, string methodName, BindingFlags flags, long genericParamCount, Type[] parameters)
  • public static MethodInfo GetMethod(this Type type, string name, BindingFlags flags, Type[] parameters)
  • public static TypeCode GetTypeCode(this Type t)
  • public static bool IsImmutable(this Type type)

DotNext.Resources

• public struct ResourceEntry
  • public ResourceManager Manager { get; }
  • public string Name { get; }
  • public static string op_Explicit(ref ResourceEntry entry)
  • public static Stream op_Explicit(ref ResourceEntry entry)
  • public T As<T>(CultureInfo culture = null)
  • public Stream AsStream(CultureInfo culture = null)
  • public string AsString(CultureInfo culture = null)
  • public string Format(object[] args)
• public static class ResourceManagerExtensions
  • public static ResourceEntry Get(this ResourceManager manager, string name = "")

DotNext.Runtime

• public struct Box<T> : IEquatable<Box<T>> where T : struct
  • public bool IsEmpty { get; }
  • public ref T Value { get; }
  • public Box(object boxed)
  • public Box(T value)
  • public static bool op_Equality(Box<T> x, Box<T> y)
  • public static T op_Explicit(Box<T> box)
  • public static bool op_Inequality(Box<T> x, Box<T> y)
  • public bool Equals(Box<T> other)
  • public ref T GetPinnableReference()
• public static class Intrinsics
  • public static IntPtr AddressOf<T>(ref T value)
  • public static bool AreSame<T>(ref T first, ref T second)
  • public static ref T AsRef<T>(this TypedReference reference)
  • public static void Bitcast<T, TResult>(ref T input, out TResult output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where TResult : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static T Cast<T>(object obj)
  • public static void ClearBits(Void* address, long length)
  • public static int Compare(Void* first, Void* second, long length)
  • public static void Copy<T>(ref T input, out T output) where T : struct
  • public static void Copy<T>(T* input, T* output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Copy<T>(ref T source, out T destination, long count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void CopyUnaligned<T>(T* input, T* output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static T DefaultOf<T>()
  • public static bool Equals(Void* first, Void* second, long length)
  • public static Exception Error(object obj)
  • public static T GetElement<T>(T[] array, IntPtr index)
  • public static T GetElement<T>(T[] array, UIntPtr index)
  • public static ref T GetElementReference<T>(T[] array, IntPtr index)
  • public static ref T GetElementReference<T>(T[] array, UIntPtr index)
  • public static int GetHashCode32<T>(Func<T, int, int> getter, int count, T arg, bool salted = true)
  • public static int GetHashCode32(Void* source, long length, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode32<THashFunction>(Void* source, long length, int hash, THashFunction hashFunction, bool salted = true) where THashFunction : struct, ISupplier<int, int, int>
  • public static int GetHashCode32(Void* source, long length, bool salted = true)
  • public static long GetHashCode64<T>(Func<T, int, long> getter, int count, T arg, bool salted = true)
  • public static long GetHashCode64(Void* source, long length, long hash, Func<long, long, long> hashFunction, bool salted = true)
  • public static long GetHashCode64<THashFunction>(Void* source, long length, long hash, THashFunction hashFunction, bool salted = true) where THashFunction : struct, ISupplier<long, long, long>
  • public static long GetHashCode64(Void* source, long length, bool salted = true)
  • public static IntPtr GetLength(Array array)
  • public static TBase& modreq(System.Runtime.InteropServices.InAttribute) GetReadonlyRef<T, TBase>(this T[] array, IntPtr index) where T : TBase
  • public static bool HasFlag<T>(T value, T flag) where T : struct, Enum
  • public static bool IsDefault<T>(ref T value)
  • public static bool IsExactTypeOf<T>(object obj)
  • public static bool IsNullable<T>()
  • public static int PointerHashCode(Void* pointer)
  • public static void Reverse<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static T ShallowCopy<T>(T obj)
  • public static void Swap<T>(ref T first, ref T second)
  • public static void Swap<T>(T* first, T* second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Throw(object obj)
  • public static void ThrowIfNull<T>(ref T value)
  • public static int ToInt32(bool low, bool high)
  • public static RuntimeTypeHandle TypeOf<T>()

DotNext.Runtime.CompilerServices

• public sealed class CallerMustBeSynchronizedAttribute : Attribute
  • public CallerMustBeSynchronizedAttribute()
• public sealed class FunctionalInterfaceAttribute : Attribute
  • public FunctionalInterfaceAttribute()
• public sealed class RuntimeFeaturesAttribute : Attribute
  • public bool DynamicCodeCompilation { get; set; }
  • public bool PrivateReflection { get; set; }
  • public bool RuntimeGenericInstantiation { get; set; }
  • public RuntimeFeaturesAttribute()

DotNext.Runtime.InteropServices

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

DotNext.Text

• public struct Base64Decoder
  • public bool NeedMoreData { get; }
  • public void Decode(ReadOnlySpan<char> chars, IBufferWriter<byte> output)
  • public void Decode(ref ReadOnlySequence chars, IBufferWriter<byte> output)
  • public void Decode<TConsumer>(ReadOnlySpan<char> chars, TConsumer output) where TConsumer : IReadOnlySpanConsumer<byte>
  • public void Decode<TArg>(ReadOnlySpan<char> chars, ReadOnlySpanAction<byte, TArg> callback, TArg arg)
  • public void Decode<TArg>(ReadOnlySpan<char> chars, method callback, TArg arg)
  • public void Decode(ReadOnlySpan<byte> utf8Chars, IBufferWriter<byte> output)
  • public void Decode(ref ReadOnlySequence utf8Chars, IBufferWriter<byte> output)
  • public void Decode<TConsumer>(ReadOnlySpan<byte> utf8Chars, TConsumer output) where TConsumer : IReadOnlySpanConsumer<byte>
  • public void Decode<TArg>(ReadOnlySpan<byte> utf8Chars, ReadOnlySpanAction<byte, TArg> output, TArg arg)
  • public void Decode<TArg>(ReadOnlySpan<byte> utf8Chars, method output, TArg arg)
  • public void Decode(ReadOnlySpan<byte> utf8Chars, Stream output)
• public static class EncodingExtensions
  • public static MemoryOwner<byte> GetBytes(this Encoding encoding, ReadOnlySpan<char> chars, MemoryAllocator<byte> allocator = null)
  • public static MemoryOwner<char> GetChars(this Encoding encoding, ReadOnlySpan<byte> bytes, MemoryAllocator<char> allocator = null)
  • public static Encoding WithoutPreamble(this Encoding encoding)

DotNext.Text.Json

• public sealed class OptionalConverterFactory : JsonConverterFactory
  • public OptionalConverterFactory()

DotNext.Threading

• public static class AsyncDelegate
  • public static Task InvokeAsync<D>(this D delegate, Action<D> invoker, CancellationToken token = default) where D : MulticastDelegate
  • public static Task InvokeAsync<E>(this EventHandler<E> handler, object sender, E args, CancellationToken token = default)
  • public static Task BeginInvoke(this Action<object> action, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null)
  • public static Task BeginInvoke(this Action<object, CancellationToken> action, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null, CancellationToken token = default)
  • public static Task<TResult> BeginInvoke<TResult>(this Func<object, TResult> function, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null)
  • public static Task<TResult> BeginInvoke<TResult>(this Func<object, CancellationToken, TResult> function, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null, CancellationToken token = default)
  • public static Task InvokeAsync<TDelegate>(this TDelegate delegate, Action<TDelegate> invoker, CancellationToken token = default) where TDelegate : MulticastDelegate
  • public static Task InvokeAsync<TEventArgs>(this EventHandler<TEventArgs> handler, object sender, TEventArgs args, CancellationToken token = default)
• public struct Atomic<T> : IStrongBox, ICloneable where T : struct
  • public sealed delegate Accumulator<T> : MulticastDelegate where T : struct
  • public sealed delegate Updater<T> : MulticastDelegate where T : struct
  • public T Value { get; set; }
  • public void AccumulateAndGet(ref T x, Accumulator<T> accumulator, out T result)
  • public Atomic<T> Clone()
  • public bool CompareAndSet(ref T expected, ref T update)
  • 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(ref T update, ref T expected, out T result)
  • 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 void Exchange(ref T update, out T previous)
  • public void GetAndAccumulate(ref T x, Accumulator<T> accumulator, out T result)
  • public void GetAndUpdate(Updater<T> updater, out T result)
  • public void Read(out T result)
  • public void Swap(ref Atomic other)
  • public void Swap(ref T other)
  • public void UpdateAndGet(Updater<T> updater, out T result)
  • public void Write(ref T newValue)
• public struct AtomicBoolean : IEquatable<bool>, ISerializable
  • public bool AccumulateAndGet(bool x, method accumulator)
  • public bool GetAndAcummulate(bool x, Func<bool, bool, bool> accumulator)
  • public bool GetAndAccumulate(bool x, Func<bool, bool, bool> accumulator)
  • public bool GetAndAccumulate(bool x, method accumulator)
  • public bool GetAndUpdate(method updater)
  • public bool UpdateAndGet(method updater)
• public static class AtomicDouble
  • public static double AccumulateAndGet(this ref double value, double x, method accumulator)
  • public static double AccumulateAndGet(this double[] array, long index, double x, method accumulator)
  • public static long CompareExchange(this long[] array, long index, long update, long comparand)
  • public static double CompareExchange(this double[] array, long index, double update, double comparand)
  • public static double GetAndAccumulate(this ref double value, double x, method accumulator)
  • public static double GetAndAccumulate(this double[] array, long index, double x, method accumulator)
  • public static double GetAndUpdate(this ref double value, method updater)
  • public static double GetAndUpdate(this double[] array, long index, method updater)
  • public static double UpdateAndGet(this ref double value, method updater)
  • public static double UpdateAndGet(this double[] array, long index, method updater)
• public static class AtomicEnum
  • public static TEnum VolatileRead<TEnum>(this ref TEnum value) where TEnum : struct, Enum
  • public static void VolatileWrite<TEnum>(this ref TEnum value, TEnum newValue) where TEnum : struct, Enum
• public struct AtomicEnum<TEnum> : IEquatable<TEnum>, ISerializable where TEnum : struct, Enum
  • public TEnum Value { get; set; }
  • public AtomicEnum(TEnum value)
  • public TEnum AccumulateAndGet(TEnum x, Func<TEnum, TEnum, TEnum> accumulator)
  • public TEnum AccumulateAndGet(TEnum x, method accumulator)
  • public bool CompareAndSet(TEnum expected, TEnum update)
  • public TEnum CompareExchange(TEnum update, TEnum expected)
  • public bool Equals(TEnum other)
  • public TEnum GetAndAccumulate(TEnum x, Func<TEnum, TEnum, TEnum> accumulator)
  • public TEnum GetAndAccumulate(TEnum x, method accumulator)
  • public TEnum GetAndSet(TEnum update)
  • public TEnum GetAndUpdate(Func<TEnum, TEnum> updater)
  • public TEnum GetAndUpdate(method updater)
  • public TEnum SetAndGet(TEnum update)
  • public TEnum UpdateAndGet(Func<TEnum, TEnum> updater)
  • public TEnum UpdateAndGet(method updater)
• public static class AtomicInt32
  • public static int AccumulateAndGet(this ref int value, int x, method accumulator)
  • public static int AccumulateAndGet(this int[] array, long index, int x, method accumulator)
  • public static int GetAndAccumulate(this ref int value, int x, method accumulator)
  • public static int GetAndAccumulate(this int[] array, long index, int x, method accumulator)
  • public static int GetAndUpdate(this ref int value, method updater)
  • public static int GetAndUpdate(this int[] array, long index, method updater)
  • public static int UpdateAndGet(this ref int value, method updater)
  • public static int UpdateAndGet(this int[] array, long index, method updater)
• public static class AtomicInt64
  • public static long AccumulateAndGet(this ref long value, long x, method accumulator)
  • public static long AccumulateAndGet(this long[] array, long index, long x, method accumulator)
  • public static long GetAndAccumulate(this ref long value, long x, method accumulator)
  • public static long GetAndAccumulate(this long[] array, long index, long x, method accumulator)
  • public static long GetAndUpdate(this ref long value, method updater)
  • public static long GetAndUpdate(this long[] array, long index, method updater)
  • public static long UpdateAndGet(this ref long value, method updater)
  • public static long UpdateAndGet(this long[] array, long index, method updater)
• public static class AtomicIntPtr
  • public static IntPtr AccumulateAndGet(this ref IntPtr value, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
  • public static IntPtr AccumulateAndGet(this ref IntPtr value, IntPtr x, method accumulator)
  • public static IntPtr AccumulateAndGet(this IntPtr[] array, long index, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
  • public static IntPtr AccumulateAndGet(this IntPtr[] array, long index, IntPtr x, method accumulator)
  • public static IntPtr Add(this ref IntPtr value, IntPtr operand)
  • public static bool CompareAndSet(this ref IntPtr value, IntPtr expected, IntPtr update)
  • public static bool CompareAndSet(this IntPtr[] array, long index, IntPtr expected, IntPtr update)
  • public static IntPtr CompareExchange(this IntPtr[] array, long index, IntPtr update, IntPtr comparand)
  • public static IntPtr DecrementAndGet(this ref IntPtr value)
  • public static IntPtr DecrementAndGet(this IntPtr[] array, long index)
  • public static IntPtr GetAndAccumulate(this ref IntPtr value, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
  • public static IntPtr GetAndAccumulate(this ref IntPtr value, IntPtr x, method accumulator)
  • public static IntPtr GetAndAccumulate(this IntPtr[] array, long index, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
  • public static IntPtr GetAndAccumulate(this IntPtr[] array, long index, IntPtr x, method accumulator)
  • public static IntPtr GetAndSet(this ref IntPtr value, IntPtr update)
  • public static IntPtr GetAndSet(this IntPtr[] array, long index, IntPtr update)
  • public static IntPtr GetAndUpdate(this ref IntPtr value, Func<IntPtr, IntPtr> updater)
  • public static IntPtr GetAndUpdate(this ref IntPtr value, method updater)
  • public static IntPtr GetAndUpdate(this IntPtr[] array, long index, Func<IntPtr, IntPtr> updater)
  • public static IntPtr GetAndUpdate(this IntPtr[] array, long index, method updater)
  • public static IntPtr IncrementAndGet(this ref IntPtr value)
  • public static IntPtr IncrementAndGet(this IntPtr[] array, long index)
  • public static IntPtr SetAndGet(this ref IntPtr value, IntPtr update)
  • public static IntPtr SetAndGet(this IntPtr[] array, long index, IntPtr update)
  • public static IntPtr UpdateAndGet(this ref IntPtr value, Func<IntPtr, IntPtr> updater)
  • public static IntPtr UpdateAndGet(this ref IntPtr value, method updater)
  • public static IntPtr UpdateAndGet(this IntPtr[] array, long index, Func<IntPtr, IntPtr> updater)
  • public static IntPtr UpdateAndGet(this IntPtr[] array, long index, method updater)
  • public static IntPtr VolatileRead(this ref IntPtr value)
  • public static IntPtr VolatileRead(this IntPtr[] array, long index)
  • public static void VolatileWrite(this ref IntPtr value, IntPtr newValue)
  • public static void VolatileWrite(this IntPtr[] array, long index, IntPtr value)
• public static class AtomicReference
  • public static T AccumulateAndGet<T>(ref T value, T x, method accumulator)
  • public static T AccumulateAndGet<T>(this T[] array, long index, T x, method accumulator)
  • public static T GetAndAccumulate<T>(ref T value, T x, method accumulator)
  • public static T GetAndAccumulate<T>(this T[] array, long index, T x, method accumulator)
  • public static T GetAndUpdate<T>(ref T value, method updater)
  • public static T GetAndUpdate<T>(this T[] array, long index, method updater)
  • public static T UpdateAndGet<T>(ref T value, method updater)
  • public static T UpdateAndGet<T>(this T[] array, long index, method updater)
• public struct AtomicReference<T> : IEquatable<T>
• public static class AtomicSingle
  • public static float AccumulateAndGet(this ref float value, float x, method accumulator)
  • public static float AccumulateAndGet(this float[] array, long index, float x, method accumulator)
  • public static float GetAndAccumulate(this ref float value, float x, method accumulator)
  • public static float GetAndAccumulate(this float[] array, long index, float x, method accumulator)
  • public static float GetAndUpdate(this ref float value, method updater)
  • public static float GetAndUpdate(this float[] array, long index, method updater)
  • public static float UpdateAndGet(this ref float value, method updater)
  • public static float UpdateAndGet(this float[] array, long index, method updater)
• public static class AtomicUInt32
  • public static uint AccumulateAndGet(this ref uint value, uint x, Func<uint, uint, uint> accumulator)
  • public static uint AccumulateAndGet(this ref uint value, uint x, method accumulator)
  • public static uint AccumulateAndGet(this uint[] array, long index, uint x, Func<uint, uint, uint> accumulator)
  • public static uint AccumulateAndGet(this uint[] array, long index, uint x, method accumulator)
  • public static uint Add(this ref uint value, uint operand)
  • public static uint Add(this uint[] array, long index, uint operand)
  • public static bool CompareAndSet(this ref uint value, uint expected, uint update)
  • public static bool CompareAndSet(this uint[] array, long index, uint expected, uint update)
  • public static uint CompareExchange(this uint[] array, long index, uint update, uint comparand)
  • public static uint DecrementAndGet(this ref uint value)
  • public static uint DecrementAndGet(this uint[] array, long index)
  • public static uint GetAndAccumulate(this ref uint value, uint x, Func<uint, uint, uint> accumulator)
  • public static uint GetAndAccumulate(this ref uint value, uint x, method accumulator)
  • public static uint GetAndAccumulate(this uint[] array, long index, uint x, Func<uint, uint, uint> accumulator)
  • public static uint GetAndAccumulate(this uint[] array, long index, uint x, method accumulator)
  • public static uint GetAndSet(this ref uint value, uint update)
  • public static uint GetAndSet(this uint[] array, long index, uint update)
  • public static uint GetAndUpdate(this ref uint value, Func<uint, uint> updater)
  • public static uint GetAndUpdate(this ref uint value, method updater)
  • public static uint GetAndUpdate(this uint[] array, long index, Func<uint, uint> updater)
  • public static uint GetAndUpdate(this uint[] array, long index, method updater)
  • public static uint IncrementAndGet(this ref uint value)
  • public static uint IncrementAndGet(this uint[] array, long index)
  • public static uint SetAndGet(this ref uint value, uint update)
  • public static uint SetAndGet(this uint[] array, long index, uint update)
  • public static uint UpdateAndGet(this ref uint value, Func<uint, uint> updater)
  • public static uint UpdateAndGet(this ref uint value, method updater)
  • public static uint UpdateAndGet(this uint[] array, long index, Func<uint, uint> updater)
  • public static uint UpdateAndGet(this uint[] array, long index, method updater)
  • public static uint VolatileRead(this ref uint value)
  • public static uint VolatileRead(this uint[] array, long index)
  • public static void VolatileWrite(this ref uint value, uint newValue)
  • public static void VolatileWrite(this uint[] array, long index, uint value)
• public static class AtomicUInt64
  • public static ulong AccumulateAndGet(this ref ulong value, ulong x, Func<ulong, ulong, ulong> accumulator)
  • public static ulong AccumulateAndGet(this ref ulong value, ulong x, method accumulator)
  • public static ulong AccumulateAndGet(this ulong[] array, long index, ulong x, Func<ulong, ulong, ulong> accumulator)
  • public static ulong AccumulateAndGet(this ulong[] array, long index, ulong x, method accumulator)
  • public static ulong Add(this ref ulong value, ulong operand)
  • public static ulong Add(this ulong[] array, long index, ulong operand)
  • public static bool CompareAndSet(this ref ulong value, ulong expected, ulong update)
  • public static bool CompareAndSet(this ulong[] array, long index, ulong expected, ulong update)
  • public static ulong CompareExchange(this ulong[] array, long index, ulong update, ulong comparand)
  • public static ulong DecrementAndGet(this ref ulong value)
  • public static ulong DecrementAndGet(this ulong[] array, long index)
  • public static ulong GetAndAccumulate(this ref ulong value, ulong x, Func<ulong, ulong, ulong> accumulator)
  • public static ulong GetAndAccumulate(this ref ulong value, ulong x, method accumulator)
  • public static ulong GetAndAccumulate(this ulong[] array, long index, ulong x, Func<ulong, ulong, ulong> accumulator)
  • public static ulong GetAndAccumulate(this ulong[] array, long index, ulong x, method accumulator)
  • public static ulong GetAndSet(this ref ulong value, ulong update)
  • public static ulong GetAndSet(this ulong[] array, long index, ulong update)
  • public static ulong GetAndUpdate(this ref ulong value, Func<ulong, ulong> updater)
  • public static ulong GetAndUpdate(this ref ulong value, method updater)
  • public static ulong GetAndUpdate(this ulong[] array, long index, Func<ulong, ulong> updater)
  • public static ulong GetAndUpdate(this ulong[] array, long index, method updater)
  • public static ulong IncrementAndGet(this ref ulong value)
  • public static ulong IncrementAndGet(this ulong[] array, long index)
  • public static ulong SetAndGet(this ref ulong value, ulong update)
  • public static ulong SetAndGet(this ulong[] array, long index, ulong update)
  • public static ulong UpdateAndGet(this ref ulong value, Func<ulong, ulong> updater)
  • public static ulong UpdateAndGet(this ref ulong value, method updater)
  • public static ulong UpdateAndGet(this ulong[] array, long index, Func<ulong, ulong> updater)
  • public static ulong UpdateAndGet(this ulong[] array, long index, method updater)
  • public static ulong VolatileRead(this ref ulong value)
  • public static ulong VolatileRead(this ulong[] array, long index)
  • public static void VolatileWrite(this ref ulong value, ulong newValue)
  • public static void VolatileWrite(this ulong[] array, long index, ulong value)
• public struct Lock : IDisposable, IEquatable<Lock>
  • public static Lock Monitor(object obj)
  • public static Lock Monitor(object obj, bool useSpinWait = false)
• public static class LockAcquisition
  • public static Holder AcquireLock(this SemaphoreSlim semaphore)
  • public static Holder AcquireLock(this SemaphoreSlim semaphore, TimeSpan timeout)
  • public static Holder AcquireReadLock(this ReaderWriterLockSlim rwLock)
  • public static Holder AcquireReadLock(this ReaderWriterLockSlim rwLock, TimeSpan timeout)
  • public static Holder AcquireUpgradeableReadLock(this ReaderWriterLockSlim rwLock)
  • public static Holder AcquireUpgradeableReadLock(this ReaderWriterLockSlim rwLock, TimeSpan timeout)
  • public static Holder AcquireWriteLock(this ReaderWriterLockSlim rwLock)
  • public static Holder AcquireWriteLock(this ReaderWriterLockSlim rwLock, TimeSpan timeout)
• public struct ReaderWriterSpinLock
  • public struct LockStamp : IEquatable<LockStamp>
  • public int CurrentReadCount { get; }
  • public bool IsReadLockHeld { get; }
  • public bool IsWriteLockHeld { get; }
  • public void EnterReadLock()
  • public void EnterWriteLock()
  • public void ExitReadLock()
  • public void ExitWriteLock()
  • public bool TryEnterReadLock()
  • public bool TryEnterReadLock(TimeSpan timeout, CancellationToken token = default)
  • public bool TryEnterWriteLock()
  • public bool TryEnterWriteLock(TimeSpan timeout, CancellationToken token = default)
  • public LockStamp TryOptimisticRead()
  • public bool Validate(ref LockStamp stamp)
• 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 bool Expired { get; }
  • public bool IsExpired { get; }
  • public bool IsInfinite { get; }
  • public TimeSpan? RemainingTime { get; }
  • public TimeSpan Value { get; }
  • public void ThrowIfExpired(out TimeSpan remaining)

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> OnCanceled<T, TConstant>(this Task<T> task, TaskScheduler scheduler = null) where TConstant : Constant<T>
  • public static Task<Task> OnCompleted(this Task task)
  • public static Task<Task<TResult>> OnCompleted<TResult>(this Task<TResult> task)
  • public static Task<T> OnFaulted<T, TConstant>(this Task<T> task, TaskScheduler scheduler = null) where TConstant : Constant<T>
  • public static Task<T> OnFaulted<T, TConstant>(this Task<T> task, Predicate<AggregateException> filter, TaskScheduler scheduler = null) where TConstant : Constant<T>
  • public static Task<T> OnFaultedOrCanceled<T, TConstant>(this Task<T> task, TaskScheduler scheduler = null) where TConstant : Constant<T>
  • public static Task<T> OnFaultedOrCanceled<T, TConstant>(this Task<T> task, Predicate<AggregateException> filter, TaskScheduler scheduler = null) where TConstant : Constant<T>
• public static class Conversion
  • public static Task<O> Convert<I, O>(this Task<I> task, Converter<I, O> converter)
  • public static Task<O> Convert<I, O>(this Task<I> task, Converter<I, Task<O>> converter)
  • public static DynamicTaskAwaitable AsDynamic(this Task task)
  • public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task) where TInput : TOutput
  • public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task, Converter<TInput, TOutput> converter)
  • public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task, Converter<TInput, Task<TOutput>> converter)
  • public static Task<T?> ToNullable<T>(this Task<T> task) where T : struct
• public struct DynamicTaskAwaitable
  • public struct Awaiter : IFuture, INotifyCompletion, ICriticalNotifyCompletion
  • public DynamicTaskAwaitable ConfigureAwait(bool continueOnCapturedContext)
  • public Awaiter GetAwaiter()
• public interface IFuture : INotifyCompletion
  • bool IsCompleted { get; }
• public static class Synchronization
  • public static R GetResult<R>(this Task<R> task, TimeSpan timeout)
  • public static R GetResult<R>(this Task<R> task, CancellationToken token)
  • public static Result<TResult> GetResult<TResult>(this Task<TResult> task, TimeSpan timeout)
  • public static Result<TResult> GetResult<TResult>(this Task<TResult> task, CancellationToken token)
  • public static Result<object> GetResult(this Task task, CancellationToken token)
  • public static Result<object> GetResult(this Task task, TimeSpan timeout)
  • public static Task<bool> WaitAsync(this Task task, TimeSpan timeout, CancellationToken token = default)

DotNext.VariantType

• public interface IVariant : IDynamicMetaObjectProvider
  • bool Equals<V>(V other) where V : IVariant
  • bool Equals<TVariant>(TVariant other) where TVariant : IVariant
• public struct Variant<T1, T2> : IEquatable<Variant<T1, T2>>, IVariant, IDynamicMetaObjectProvider
  • public bool IsPresent { get; }
  • public bool IsNull { get; }
  • public Optional<R> Convert<R>(Converter<T1, R> mapper1, Converter<T2, R> mapper2)
  • public Variant<U1, U2> Convert<U1, U2>(Converter<T1, U1> mapper1, Converter<T2, U2> mapper2)
  • public bool Equals<V>(V other) where V : IVariant
  • public Optional<TResult> Convert<TResult>(Converter<T1, TResult> mapper1, Converter<T2, TResult> mapper2)
  • public Optional<TResult> Convert<TResult>(method mapper1, method mapper2)
  • public Variant<TResult1, TResult2> Convert<TResult1, TResult2>(Converter<T1, TResult1> mapper1, Converter<T2, TResult2> mapper2)
  • public Variant<TResult1, TResult2> Convert<TResult1, TResult2>(method mapper1, method mapper2)
  • public void Deconstruct(out T1 value1, out T2 value2)
  • public bool Equals<TOther>(TOther other) where TOther : IVariant
• public struct Variant<T1, T2, T3> : IVariant, IDynamicMetaObjectProvider, IEquatable<Variant<T1, T2, T3>>
  • public bool IsPresent { get; }
  • public bool IsNull { get; }
  • public bool Equals<V>(V other) where V : IVariant
  • public void Deconstruct(out T1 value1, out T2 value2, out T3 value3)
  • public bool Equals<TOther>(TOther other) where TOther : IVariant
• public struct Variant<T1, T2, T3, T4> : IVariant, IDynamicMetaObjectProvider, IEquatable<Variant<T1, T2, T3, T4>>
  • public bool IsPresent { get; }
  • public bool IsNull { get; }
  • public bool Equals<V>(V other) where V : IVariant
  • public void Deconstruct(out T1 value1, out T2 value2, out T3 value3, out T4 value4)
  • public bool Equals<TOther>(TOther other) where TOther : IVariant