DotNext by .NET Foundation and Contributors

API Diff between 5.0.0 and 0.1.1

1427 Additions 141 Removals

DotNext

public enum BoundType
public struct Activator<T> : ISupplier<T>, IFunctional<Func<T>>
public static class BasicExtensions
- public static T As<T>(this T obj)
- public static DisclosedEndpoint<T> Disclosed<T>(this T value) where T : IComparable<T>
- public static EnclosedEndpoint<T> Enclosed<T>(this T value) where T : IComparable<T>
- public static UserDataStorage GetUserData<T>(this T obj)
- public static bool IsBetween<T, TLowerBound, TUpperBound>(this T value, TLowerBound lowerBound, TUpperBound upperBound) where TLowerBound : IRangeEndpoint<T> where TUpperBound : IRangeEndpoint<T>
- public static bool IsNullOrEmpty(this Array array)
- public static bool IsOneOf<T>(this T value, ReadOnlySpan<T> candidates)
- public static bool TryGetValue<T>(this T? nullable, out T value) where T : struct
public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static BitwiseComparer<T> Instance { get; }
- public static int Compare<TOther>(ref T first, ref TOther second) where TOther : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static bool Equals<TOther>(ref T first, ref TOther second) where TOther : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int GetHashCode(ref T value, bool salted = true)
public abstract class CharComparer : IEqualityComparer<char>, IComparer<char>
- protected CharComparer()
- public static int Compare(char x, char y, StringComparison comparisonType)
- public static CharComparer Create(CultureInfo culture, CompareOptions options)
- public static bool Equals(char x, char y, StringComparison comparisonType)
- public static CharComparer FromComparison(StringComparison comparison)
- public static int GetHashCode(char ch, StringComparison comparisonType)
- public abstract int Compare(char x, char y)
- public abstract bool Equals(char x, char y)
- public abstract int GetHashCode(char ch)
public static class Comparable
public struct Consumer<T> : IConsumer<T>, IFunctional<Action<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>, IFunctional<Action<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 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 Func<bool> Bind<T>(this Predicate<T> predicate, T 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 static Predicate<T> Unbind<T>(this Func<bool> func)
public struct DelegatingConsumer<T> : IConsumer<T>, IFunctional<Action<T>>, IEquatable<DelegatingConsumer<T>>
- public bool IsEmpty { get; }
- public DelegatingConsumer(Action<T> action)
- public static bool op_Equality(DelegatingConsumer<T> left, DelegatingConsumer<T> right)
- public static DelegatingConsumer<T> op_Implicit(Action<T> action)
- public static bool op_Inequality(DelegatingConsumer<T> left, DelegatingConsumer<T> right)
- public bool Equals(DelegatingConsumer<T> other)
public struct DelegatingSupplier<TResult> : ISupplier<TResult>, IFunctional<Func<TResult>>, IEquatable<DelegatingSupplier<TResult>>
- public bool IsEmpty { get; }
- public DelegatingSupplier(Func<TResult> func)
- public static bool op_Equality(DelegatingSupplier<TResult> left, DelegatingSupplier<TResult> right)
- public static DelegatingSupplier<TResult> op_Implicit(Func<TResult> func)
- public static bool op_Inequality(DelegatingSupplier<TResult> left, DelegatingSupplier<TResult> right)
- public bool Equals(DelegatingSupplier<TResult> other)
public struct DelegatingSupplier<T, TResult> : ISupplier<T, TResult>, IFunctional<Func<T, TResult>>, IEquatable<DelegatingSupplier<T, TResult>>
- public bool IsEmpty { get; }
- public DelegatingSupplier(Func<T, TResult> func)
- public static bool op_Equality(DelegatingSupplier<T, TResult> left, DelegatingSupplier<T, TResult> right)
- public static DelegatingSupplier<T, TResult> op_Implicit(Func<T, TResult> func)
- public static bool op_Inequality(DelegatingSupplier<T, TResult> left, DelegatingSupplier<T, TResult> right)
- public bool Equals(DelegatingSupplier<T, TResult> other)
public struct DelegatingSupplier<T1, T2, TResult> : ISupplier<T1, T2, TResult>, IFunctional<Func<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> left, DelegatingSupplier<T1, T2, TResult> right)
- public static DelegatingSupplier<T1, T2, TResult> op_Implicit(Func<T1, T2, TResult> func)
- public static bool op_Inequality(DelegatingSupplier<T1, T2, TResult> left, DelegatingSupplier<T1, T2, TResult> right)
- public bool Equals(DelegatingSupplier<T1, T2, TResult> other)
public struct DisclosedEndpoint<T> : IFiniteRangeEndpoint<T>, IRangeEndpoint<T> where T : IComparable<T>
- public T Value { get; set; }
- public static DisclosedEndpoint<T> op_Implicit(T value)
- public static EnclosedEndpoint<T> op_OnesComplement(DisclosedEndpoint<T> endpoint)
public abstract class Disposable : IDisposable
- protected Task DisposedTask { get; }
- protected bool IsDisposing { get; }
- protected bool IsDisposingOrDisposed { get; }
- public static void Dispose(IDisposable[] objects)
- public static void Dispose(ReadOnlySpan<IDisposable> objects)
- public static ValueTask DisposeAsync(IEnumerable<IAsyncDisposable> objects)
- public static ValueTask DisposeAsync(IAsyncDisposable[] objects)
- protected void ThrowIfDisposed()
- protected ValueTask DisposeAsync()
- protected virtual ValueTask DisposeAsyncCore()
- protected Task<T> GetDisposedTask<T>()
- protected bool TryBeginDispose()
- protected bool TrySetDisposedException<T>(TaskCompletionSource<T> source)
- protected bool TrySetDisposedException(TaskCompletionSource source)
public struct Enum<E> : IEquatable<E>, IComparable<E>, IFormattable where E : struct, Enum
public struct EnclosedEndpoint<T> : IFiniteRangeEndpoint<T>, IRangeEndpoint<T> where T : IComparable<T>
- public T Value { get; set; }
- public static EnclosedEndpoint<T> op_Implicit(T value)
- public static DisclosedEndpoint<T> op_OnesComplement(EnclosedEndpoint<T> endpoint)
public static class EnumConverter
- public static TValue FromEnum<TEnum, TValue>(TEnum value) where TEnum : struct, Enum where TValue : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), INumberBase<TValue>, IConvertible
- public static TypeCode GetTypeCode<TEnum>() where TEnum : struct, Enum
- public static TEnum ToEnum<TEnum, TValue>(TValue value) where TEnum : struct, Enum where TValue : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), INumberBase<TValue>, IConvertible
public 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, T> Identity<T>(this Action<T> action)
- public static Func<T, bool> IsNotNull<T>()
- public static Func<T, bool> IsNull<T>()
- public static Func<object, bool> IsTypeOf<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 static class ObjectExtensions
public static class OneDimensionalArray
public interface IConsumer<T> : IFunctional<Action<T>>
- void Invoke(T arg)
public interface IFiniteRangeEndpoint<T> : IRangeEndpoint<T>
- T Value { get; }
public interface IOptionMonad<T> : ISupplier<object>, IFunctional<Func<object>>
- bool HasValue { get; }
- T ValueOrDefault { get; }
- T Or(T defaultValue)
- T OrInvoke(Func<T> defaultFunc)
- bool TryGet(out T value)
public interface IOptionMonad<T, TSelf> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>> where TSelf : struct, IOptionMonad<T, TSelf>
- T op_Explicit(TSelf& modreq(System.Runtime.InteropServices.InAttribute) container)
- TSelf op_Implicit(T value)
public interface IRangeEndpoint<T>
- IRangeEndpoint<T> Infinity { get; }
- bool IsOnLeft(T value)
- bool IsOnRight(T value)
public interface IResettable
- void Reset()
public interface IResultMonad<T, TError> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>
- TError Error { get; }
- T OrInvoke(Func<TError, T> defaultFunc)
public interface IResultMonad<T, TError, TSelf> : IResultMonad<T, TError>, IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>, IOptionMonad<T, TSelf> where TSelf : struct, IResultMonad<T, TError, TSelf>
- TSelf FromError(TError error)
public interface ISupplier<TResult> : IFunctional<Func<TResult>>
- ISupplier<TResult> NullOrDefault { get; }
- TResult Invoke()
public interface ISupplier<T, TResult> : IFunctional<Func<T, TResult>>
- TResult Invoke(T arg)
public interface ISupplier<T1, T2, TResult> : IFunctional<Func<T1, T2, TResult>>
- TResult Invoke(T1 arg1, T2 arg2)
public static class Optional
- public static Task<Optional<O>> Convert<I, O>(this Task<Optional> 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 Optional<T> Create<T, TMonad>(TMonad value) where TMonad : struct, IOptionMonad<T>
- public static Optional<T> Flatten<T>(this ref Optional optional)
- 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, IOptionMonad<T, Optional<T>>, IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>
- 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 T ValueOrDefault { get; }
- public T& modreq(System.Runtime.InteropServices.InAttribute) ValueRef { get; }
- public static bool HasValue(ref T value)
- public static bool IsValueDefined(T value)
- public static T op_BitwiseOr(ref Optional optional, T defaultValue)
- public Optional Convert(Converter<T, U> mapper)
- public Optional Convert(Converter<T, Optional> 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 T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<TException>() where TException : Exception
- public T& modreq(System.Runtime.InteropServices.InAttribute) GetReference(Func<Exception> exceptionFactory)
- public T& modreq(System.Runtime.InteropServices.InAttribute) GetReference(method exceptionFactory)
- public Optional<T> If(method condition)
- public T OrDefault()
- 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> False<T>()
- public static Predicate<T> Constant<T>(bool value)
- public static Predicate<T?> HasValue<T>() where T : struct
- public static Predicate<object> IsTypeOf<T>()
- public static Predicate<T> True<T>()
- public static Result<bool> TryInvoke<T>(this Predicate<T> predicate, T obj)
public static class RandomExtensions
- public static void GetItems<T>(this Random random, Span<T> buffer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void GetItems<T>(this RandomNumberGenerator random, Span<T> buffer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static 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 void NextChars(this Random random, ReadOnlySpan<char> allowedChars, Span<char> buffer)
- public static void NextChars(this RandomNumberGenerator random, ReadOnlySpan<char> allowedChars, Span<char> buffer)
- public static string NextString(this Random random, char[] allowedChars, int length)
- public static string NextString(this Random random, ReadOnlySpan<char> allowedChars, int length)
- public static string NextString(this RandomNumberGenerator random, char[] allowedChars, int length)
- public static string NextString(this RandomNumberGenerator random, ReadOnlySpan<char> allowedChars, int length)
- public static Optional<T> Peek<T>(this Random random, IReadOnlyCollection<T> collection)
- public static Optional<T> Peek<T>(this Random random, ReadOnlySpan<T> span)
- public static void Shuffle<T>(this Random random, IList<T> list)
public static class 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 Result<T> FromException<T>(Exception e)
- public static Result<T> FromValue<T>(T value)
- 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 static T? OrNull<T, TError>(this ref Result result) where T : struct where TError : struct, Enum
public struct Result<T> : IResultMonad<T, Exception, Result<T>>, IResultMonad<T, Exception>, IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>, IOptionMonad<T, Result<T>>
- public Exception Error { get; }
- public bool IsSuccessful { get; }
- public T Value { get; }
- public T ValueOrDefault { get; }
- public T& modreq(System.Runtime.InteropServices.InAttribute) ValueRef { 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_BitwiseOr(ref Result result, T defaultValue)
- public static Result<T> op_BitwiseOr(ref Result x, ref Result y)
- 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 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 struct Result<T, TError> : IResultMonad<T, TError, Result<T, TError>>, IResultMonad<T, TError>, IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>, IOptionMonad<T, Result<T, TError>> where TError : struct, Enum
- public TError Error { get; }
- public bool IsSuccessful { get; }
- public T Value { get; }
- public T ValueOrDefault { get; }
- public T& modreq(System.Runtime.InteropServices.InAttribute) ValueRef { get; }
- public Result(T value)
- public Result(TError error)
- public static bool op_BitwiseAnd(ref Result left, ref Result right)
- public static T op_BitwiseOr(ref Result result, T defaultValue)
- public static Result<T, TError> op_BitwiseOr(ref Result x, ref Result y)
- public static T op_Explicit(ref Result result)
- public static bool op_False(ref Result result)
- public static Optional<T> op_Implicit(ref Result result)
- public static Result<T> op_Implicit(ref Result result)
- public static Result<T, TError> op_Implicit(T result)
- public static bool op_True(ref Result result)
- public Result<object, TError> Box()
- public Result<TResult, TError> Convert<TResult>(Converter<T, TResult> converter)
- public Result<TResult, TError> Convert<TResult>(method converter)
- public T Or(T defaultValue)
- public T OrInvoke(Func<T> defaultFunc)
- public T OrInvoke(method defaultFunc)
- public T OrInvoke(Func<TError, T> defaultFunc)
- public T OrInvoke(method defaultFunc)
- public T OrThrow(Func<TError, Exception> exceptionFactory)
- public T OrThrow(method exceptionFactory)
- public Result<T> ToResult()
- public bool TryGet(out T value)
- public Optional<T> TryGet()
public static class ServiceProviderFactory
- public sealed class Builder : ISupplier<IServiceProvider>, IFunctional<Func<IServiceProvider>>, IResettable
- 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 int BitwiseCompare<T>(this ReadOnlySpan<T> x, ReadOnlySpan<T> y) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static bool BitwiseEquals<T>(this ReadOnlySpan<T> x, ReadOnlySpan<T> y) 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<char> Concat(ReadOnlySpan<string> values, MemoryAllocator<char> allocator = null)
- public static ReadOnlySpan<TBase> Contravariance<T, TBase>(this ReadOnlySpan<T> span) where T : TBase
- public static 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 Optional<T> FirstOrNone<T>(this ReadOnlySpan<T> span, Predicate<T> filter)
- 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 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 Initialize<T>(this Span<T> span)
- public static void Move<T>(this Span<T> span, Range range, Index destinationIndex)
- public static void Sort<T>(this Span<T> span, method comparison)
- public static void Swap<T>(this Span<T> x, Span<T> y)
- public static void Swap<T>(this Span<T> span, Range range1, Range range2)
- public static Span<T> TrimLength<T>(this Span<T> span, int maxLength)
- public static ReadOnlySpan<T> TrimLength<T>(this ReadOnlySpan<T> span, int maxLength)
- public static Span<T> TrimLength<T>(this Span<T> span, int maxLength, out Span rest)
public static class StringExtensions
- public static string IfNullOrEmpty(this string str, string alt)
- public static bool IsEqualIgnoreCase(this string strA, string strB)
- public static string Substring(this string str, Range range)
public struct Supplier<TResult> : ISupplier<TResult>, IFunctional<Func<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>, IFunctional<Func<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>, IFunctional<Func<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>, IFunctional<Func<TResult>>
- public bool IsEmpty { get; }
- public SupplierClosure(method ptr, TContext context)
public struct SupplierClosure<TContext, T, TResult> : ISupplier<T, TResult>, IFunctional<Func<T, TResult>>
- public bool IsEmpty { get; }
- public SupplierClosure(method ptr, TContext context)
public struct SupplierClosure<TContext, T1, T2, TResult> : ISupplier<T1, T2, TResult>, IFunctional<Func<T1, T2, TResult>>
- public bool IsEmpty { get; }
- public SupplierClosure(TContext context, method ptr)
public static class TupleExtensions
- public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
- public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
- public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
- public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
- public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
- public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
- public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
- public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
- public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
- public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
- public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
- public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
- public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
- public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
- public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
- public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
- public static object[] ToArray<T>(this T tuple) where T : ITuple
public sealed class UndefinedResultException<TError> : Exception where TError : struct, Enum
- public TError ErrorCode { get; }
public struct 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 bool IsAllocated { get; }
- public UserDataSlot()
- public static bool op_Equality(UserDataSlot<TValue> left, UserDataSlot<TValue> right)
- public static bool op_Inequality(UserDataSlot<TValue> left, UserDataSlot<TValue> right)
- public bool Equals(UserDataSlot<TValue> other)
public struct UserDataStorage
- public interface IContainer
- public bool IsValid { get; }
- 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 IReadOnlyDictionary<string, object> Capture()
- 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 struct ValueSupplier<T> : ISupplier<T>, IFunctional<Func<T>>
- public ValueSupplier(T value)
- public static ValueSupplier<T> op_Implicit(T value)

DotNext.Buffers

public struct ArrayRental<T> : IDisposable
public struct BufferConsumer<T> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>, IEquatable<BufferConsumer<T>>
- public bool IsEmpty { get; }
- public BufferConsumer(IBufferWriter<T> output)
- public static bool op_Equality(BufferConsumer<T> left, BufferConsumer<T> right)
- public static bool op_Inequality(BufferConsumer<T> left, BufferConsumer<T> right)
- public bool Equals(BufferConsumer<T> other)
public abstract class BufferWriter<T> : Disposable, IBufferWriter<T>, ISupplier<ReadOnlyMemory<T>>, IFunctional<Func<ReadOnlyMemory<T>>>, IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IGrowableBuffer<T>, IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>, IDisposable, IResettable
- public abstract int Capacity { get; set; }
- public int FreeCapacity { get; }
- public T& modreq(System.Runtime.InteropServices.InAttribute) this[int index] { get; }
- public int WrittenCount { get; set; }
- public abstract ReadOnlyMemory<T> WrittenMemory { get; }
- public void Add(T item)
- public virtual void AddAll(ICollection<T> items)
- public void Advance(int count)
- public abstract void Clear(bool reuseBuffer = false)
- public abstract MemoryOwner<T> DetachBuffer()
- public IEnumerator<T> GetEnumerator()
- public abstract Memory<T> GetMemory(int sizeHint = 0)
- public virtual Span<T> GetSpan(int sizeHint = 0)
- public void Rewind(int count)
public struct BufferWriterInterpolatedStringHandler
- public int WrittenCount { get; }
- public BufferWriterInterpolatedStringHandler(int literalLength, int formattedCount, IBufferWriter<char> buffer, IFormatProvider provider = null)
- public void AppendFormatted<T>(T value, string format = null)
- public void AppendFormatted(ReadOnlySpan<char> value)
- public void AppendFormatted(ReadOnlySpan<char> value, int alignment)
- public void AppendFormatted<T>(T value, int alignment, string format = null)
- public void AppendLiteral(string value)
public struct BufferWriterSlim<T>
- public int Capacity { get; }
- public int FreeCapacity { get; }
- public ref T this[int index] { get; }
- public int WrittenCount { get; set; }
- 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 ref T Add()
- public void Advance(int count)
- public void Clear(bool reuseBuffer = false)
- public void Dispose()
- public Span<T> GetSpan(int sizeHint = 0)
- public void Rewind(int count)
- public bool TryDetachBuffer(out MemoryOwner owner)
- public bool TryPeek(out T item)
- public bool TryPop(out T item)
- public bool TryPop(Span<T> output)
- public void Write(ReadOnlySpan<T> input)
public struct BufferWriterSlimInterpolatedStringHandler
- public int WrittenCount { get; }
- public BufferWriterSlimInterpolatedStringHandler(int literalLength, int formattedCount, ref BufferWriterSlim buffer, IFormatProvider provider = null)
- public void AppendFormatted<T>(T value, string format = null)
- public void AppendFormatted(ReadOnlySpan<char> value)
- public void AppendFormatted(ReadOnlySpan<char> value, int alignment)
- public void AppendFormatted<T>(T value, int alignment, string format = null)
- public void AppendLiteral(string value)
public static class ByteBuffer
- public static int Format<T>(this IBufferWriter<byte> writer, T value, ReadOnlySpan<char> format = default, IFormatProvider provider = null) where T : IUtf8SpanFormattable
- public static int Format<T>(this ref BufferWriterSlim writer, T value, ReadOnlySpan<char> format = default, IFormatProvider provider = null) where T : IUtf8SpanFormattable
- public static T Read<T>(this ref SpanReader reader) where T : IBinaryFormattable<T>
- public static T ReadBigEndian<T>(this ref SpanReader reader) where T : IBinaryInteger<T>
- public static T ReadLittleEndian<T>(this ref SpanReader reader) where T : IBinaryInteger<T>
- public static bool TryFormat<T>(this ref SpanWriter writer, T value, ReadOnlySpan<char> format = default, IFormatProvider provider = null) where T : IUtf8SpanFormattable
- public static bool TryRead<T>(this ref SpanReader reader, out T value) where T : IBinaryFormattable<T>
- public static bool TryWrite<T>(this ref SpanWriter writer, T value) where T : IBinaryFormattable<T>
- public static bool TryWrite(this ref SpanWriter writer, ref BigInteger value, bool isBigEndian = false, bool isUnsigned = false)
- public static void Write<T>(this IBufferWriter<byte> writer, T value) where T : IBinaryFormattable<T>
- public static int Write(this IBufferWriter<byte> writer, ref BigInteger value, bool isBigEndian = false, bool isUnsigned = false)
- public static void Write<T>(this ref BufferWriterSlim writer, T value) where T : IBinaryFormattable<T>
- public static int Write(this ref BufferWriterSlim writer, ref BigInteger value, bool isBigEndian = false, bool isUnsigned = false)
- public static void Write<T>(this ref SpanWriter writer, T value) where T : IBinaryFormattable<T>
- public static int WriteBigEndian<T>(this IBufferWriter<byte> writer, T value) where T : IBinaryInteger<T>
- public static int WriteBigEndian<T>(this ref BufferWriterSlim writer, T value) where T : IBinaryInteger<T>
- public static int WriteBigEndian<T>(this ref SpanWriter writer, T value) where T : IBinaryInteger<T>
- public static int WriteLittleEndian<T>(this IBufferWriter<byte> writer, T value) where T : IBinaryInteger<T>
- public static int WriteLittleEndian<T>(this ref BufferWriterSlim writer, T value) where T : IBinaryInteger<T>
- public static int WriteLittleEndian<T>(this ref SpanWriter writer, T value) where T : IBinaryInteger<T>
public static class CharBuffer
- public static void Concat(this IBufferWriter<char> writer, ReadOnlySpan<string> values)
- public static void Concat(this ref BufferWriterSlim writer, ReadOnlySpan<string> values)
- public static int Format<T>(this IBufferWriter<char> writer, T value, string format = null, IFormatProvider provider = null)
- public static int Format(this IBufferWriter<char> writer, CompositeFormat format, ReadOnlySpan<object> args, IFormatProvider provider = null)
- public static int Format<T>(this ref BufferWriterSlim writer, T value, string format = null, IFormatProvider provider = null)
- public static int Format(this ref BufferWriterSlim writer, CompositeFormat format, ReadOnlySpan<object> args, IFormatProvider provider = null)
- public static int Interpolate(this IBufferWriter<char> writer, IFormatProvider provider, ref BufferWriterInterpolatedStringHandler handler)
- public static int Interpolate(this IBufferWriter<char> writer, ref BufferWriterInterpolatedStringHandler handler)
- public static int Interpolate(this ref BufferWriterSlim writer, IFormatProvider provider, ref BufferWriterSlimInterpolatedStringHandler handler)
- public static int Interpolate(this ref BufferWriterSlim writer, ref BufferWriterSlimInterpolatedStringHandler handler)
- public static bool TryFormat<T>(this ref SpanWriter writer, T value, ReadOnlySpan<char> format = default, IFormatProvider provider = null) where T : ISpanFormattable
- public static bool TryFormat(this ref SpanWriter writer, CompositeFormat format, ReadOnlySpan<object> args, IFormatProvider provider = null)
- public static void Write(this IBufferWriter<char> writer, StringBuilder input)
- public static void Write(this ref BufferWriterSlim writer, StringBuilder input)
- public static void Write(this ref SpanWriter writer, StringBuilder input)
- public static void WriteLine(this IBufferWriter<char> writer)
- public static void WriteLine(this IBufferWriter<char> writer, ReadOnlySpan<char> characters)
- public static void WriteLine(this ref BufferWriterSlim writer)
- public static void WriteLine(this ref BufferWriterSlim writer, ReadOnlySpan<char> characters)
public struct DelegatingReadOnlySpanConsumer<T, TArg> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<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>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>, IDisposable, IResettable
- 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>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>
- void Invoke(ReadOnlySpan<T> span)
public static class Memory
- public static MemoryOwner<T> AllocateAtLeast<T>(this MemoryAllocator<T> allocator, int length)
- public static MemoryOwner<T> AllocateAtLeast<T>(int length)
- public static MemoryOwner<T> AllocateExactly<T>(this MemoryAllocator<T> allocator, int length)
- public static MemoryOwner<T> AllocateExactly<T>(int length)
- public static ReadOnlySequence<T> Concat<T>(this ReadOnlyMemory<T> first, ReadOnlyMemory<T> second)
- public static void CopyTo<T>(this ref ReadOnlySequence source, Span<T> destination, out int writtenCount)
- public static MemoryAllocator<T> GetArrayAllocator<T>()
- public static MemoryAllocator<T> GetPinnedArrayAllocator<T>() where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static ref T GetReference<T>(ref MemoryOwner owner)
- public static void ReleaseAll<T>(this ref MemoryOwner owner) where T : IDisposable
- public static void Resize<T>(this ref MemoryOwner owner, int newLength, MemoryAllocator<T> allocator = null)
- public static MemoryAllocator<T> ToAllocator<T>(this ArrayPool<T> pool)
- public static MemoryAllocator<T> ToAllocator<T>(this MemoryPool<T> pool)
- public static MemoryAllocator<T> ToAllocator<T>(this Func<int, IMemoryOwner<T>> provider)
- public static ReadOnlySequence<T> ToReadOnlySequence<T>(this IEnumerable<ReadOnlyMemory<T>> chunks)
- public static ReadOnlySequence<char> ToReadOnlySequence(this IEnumerable<string> strings)
- public static ReadOnlyMemory<T> TrimLength<T>(this ReadOnlyMemory<T> memory, int maxLength)
- public static Memory<T> TrimLength<T>(this Memory<T> memory, int maxLength)
- public static bool TryGetBlock<T>(this ref ReadOnlySequence sequence, int count, out ReadOnlyMemory span)
public 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>>, IFunctional<Func<Memory<T>>>, ISupplier<ReadOnlyMemory<T>>, IFunctional<Func<ReadOnlyMemory<T>>>
- public bool IsEmpty { get; }
- public ref T this[int index] { get; }
- public int Length { get; }
- public Memory<T> Memory { get; }
- public Span<T> Span { 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 void Dispose()
- public bool TryResize(int newLength)
public sealed class PoolingArrayBufferWriter<T> : BufferWriter<T>, ISupplier<ArraySegment<T>>, IFunctional<Func<ArraySegment<T>>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
- public ref T this[int index] { get; }
- public ArraySegment<T> WrittenArray { get; }
- public PoolingArrayBufferWriter(ArrayPool<T> pool = null)
- public ArraySegment<T> GetArray(int sizeHint = 0)
- public void Insert(int index, ReadOnlySpan<T> items)
- public void Overwrite(int index, ReadOnlySpan<T> items)
- public void RemoveFirst(int count)
- public void RemoveLast(int count)
public sealed class PoolingBufferWriter<T> : BufferWriter<T>, IMemoryOwner<T>, IDisposable
- public PoolingBufferWriter(MemoryAllocator<T> allocator = null)
public struct PoolingInterpolatedStringHandler : IGrowableBuffer<char>, IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IDisposable, IResettable
- public PoolingInterpolatedStringHandler(int literalLength, int formattedCount, MemoryAllocator<char> allocator, IFormatProvider provider = null)
- public void AppendFormatted<T>(T value, string format = null)
- public void AppendFormatted(ReadOnlySpan<char> value, int alignment)
- public void AppendFormatted<T>(T value, int alignment, string format = null)
- public void AppendFormatted(ReadOnlySpan<char> value)
- public void AppendLiteral(string value)
- public void Dispose()
public static class ReadOnlySequencePartitioner
- public static OrderablePartitioner<T> CreatePartitioner<T>(this ref ReadOnlySequence sequence, bool splitOnSegments = false)
public struct ReadOnlySpanConsumer<T, TArg> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>
- public bool IsEmpty { get; }
- public ReadOnlySpanConsumer(method ptr, TArg arg)
public struct SpanOwner<T>
- public static int StackallocThreshold { get; }
- public bool IsEmpty { get; }
- public ref T this[int index] { get; }
- public int Length { get; }
- public Span<T> Span { get; }
- public SpanOwner(Span<T> span)
- public SpanOwner(Span<T> span, int length)
- public SpanOwner(MemoryPool<T> pool, int minBufferSize, bool exactSize = true)
- public SpanOwner(MemoryPool<T> pool)
- public SpanOwner(int minBufferSize, bool exactSize = true)
- public static SpanOwner<T> op_Implicit(Span<T> span)
- public void Dispose()
- public ref T GetPinnableReference()
public struct SpanReader<T>
- public int ConsumedCount { get; set; }
- 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& modreq(System.Runtime.InteropServices.InAttribute) 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; set; }
- public Span<T> WrittenSpan { get; }
- public SpanWriter(Span<T> span)
- public SpanWriter(ref T reference, int length)
- public void Add(T item)
- public ref T Add()
- 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, IGrowableBuffer<T>, IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>, IDisposable, IResettable, ISupplier<ReadOnlySequence<T>>, IFunctional<Func<ReadOnlySequence<T>>>, IEnumerable<ReadOnlyMemory<T>>, IEnumerable, IBufferWriter<T>
- public struct Enumerator<T> : IEnumerator<ReadOnlyMemory<T>>, IEnumerator, IDisposable
- public SequencePosition End { get; }
- public bool IsSingleSegment { get; }
- public SequencePosition Start { get; }
- public long WrittenCount { get; }
- public SparseBufferWriter(int chunkSize, SparseBufferGrowth growth = 0, MemoryAllocator<T> allocator = null)
- public SparseBufferWriter(MemoryPool<T> pool)
- public SparseBufferWriter()
- public void Add(T item)
- public void Clear()
- public void CopyTo<TConsumer>(TConsumer consumer) where TConsumer : IReadOnlySpanConsumer<T>
- public void CopyTo<TArg>(ReadOnlySpanAction<T, TArg> writer, TArg arg)
- public int CopyTo(Span<T> output)
- public int CopyTo(Span<T> output, ref SequencePosition position)
- public void CopyTo<TConsumer>(TConsumer consumer, SequencePosition start) where TConsumer : IReadOnlySpanConsumer<T>
- public long CopyTo<TConsumer>(TConsumer consumer, ref SequencePosition position, long count) where TConsumer : IReadOnlySpanConsumer<T>
- public Enumerator<T> GetEnumerator()
- public SequencePosition GetPosition(long offset, SequencePosition origin = default)
- public ReadOnlySequence<T> Read(ref SequencePosition position, long count)
- 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.Buffers.Binary

public static class BinaryTransformations
- public static void AndNot<T>(this ReadOnlySpan<T> x, Span<T> y) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void BitwiseAnd<T>(this ReadOnlySpan<T> x, Span<T> y) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void BitwiseOr<T>(this ReadOnlySpan<T> x, Span<T> y) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void BitwiseXor<T>(this ReadOnlySpan<T> x, Span<T> y) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void OnesComplement<T>(this Span<T> values) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void Reverse<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
public struct Blittable<T> : IBinaryFormattable<Blittable<T>> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public T Value
public interface IBinaryFormattable<TSelf> where TSelf : IBinaryFormattable<TSelf>
- int Size { get; }
- MemoryOwner<byte> Format(TSelf value, MemoryAllocator<byte> allocator = null)
- TSelf Parse(ReadOnlySpan<byte> source)
- TSelf Parse(ref ReadOnlySequence source)
- bool TryFormat(TSelf value, Span<byte> destination)
- bool TryParse(ReadOnlySpan<byte> source, out TSelf result)
- void Format(Span<byte> destination)

DotNext.Buffers.Text

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

DotNext.Collections.Generic

public static class AsyncEnumerable
- public static Task<MemoryOwner<T>> CopyAsync<T>(this IAsyncEnumerable<T> enumerable, int sizeHint = 0, MemoryAllocator<T> allocator = null, CancellationToken token = default)
- public static ValueTask<Optional<T>> ElementAtAsync<T>(this IAsyncEnumerable<T> collection, int index, CancellationToken token = default)
- public static IAsyncEnumerable<T> Empty<T>()
- public static ValueTask<Optional<T>> FirstOrNoneAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default)
- public static ValueTask<Optional<T>> FirstOrNoneAsync<T>(this IAsyncEnumerable<T> seq, Predicate<T> filter, CancellationToken token = default)
- public static ValueTask<T?> FirstOrNullAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default) where T : struct
- public static ValueTask ForEachAsync<T>(this IAsyncEnumerable<T> collection, Action<T> action, CancellationToken token = default)
- public static ValueTask ForEachAsync<T>(this IAsyncEnumerable<T> collection, Func<T, CancellationToken, ValueTask> action, CancellationToken token = default)
- public static ValueTask<Optional<T>> LastOrNoneAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default)
- public static ValueTask<T?> LastOrNullAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default) where T : struct
- public static ValueTask<bool> SkipAsync<T>(this IAsyncEnumerator<T> enumerator, int count)
- public static IAsyncEnumerable<T> SkipNulls<T>(this IAsyncEnumerable<T> collection)
- public static IAsyncEnumerable<T> Throw<T>(Exception e)
- public static Task<T[]> ToArrayAsync<T>(this IAsyncEnumerable<T> collection, int initialCapacity = 10, MemoryAllocator<T> allocator = null, CancellationToken token = default)
public static class Collection
- public struct ConsumingEnumerable<T> : IEnumerable<T>, IEnumerable
- public static ReadOnlyCollectionView<T> AsReadOnlyView<T>(this ICollection<T> collection)
- public static ReadOnlyCollectionView<I, O> Convert<I, O>(this IReadOnlyCollection collection, Converter<I, O> converter)
- public static IEnumerable<T> Append<T>(this IEnumerable<T> collection, T[] items)
- public static ReadOnlyCollectionView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyCollection<TInput> collection, Converter<TInput, TOutput> converter)
- public static MemoryOwner<T> Copy<T>(this IEnumerable<T> enumerable, int sizeHint = 0, MemoryAllocator<T> allocator = null)
- public static bool ElementAt<T>(this IEnumerable<T> collection, int index, out T element)
- public static void ForEach<T>(this IEnumerable<T> collection, Action<T> action)
- public static ValueTask ForEachAsync<T>(this IEnumerable<T> collection, Func<T, CancellationToken, ValueTask> action, CancellationToken token = default)
- public static ConsumingEnumerable<T> GetConsumer<T>(this IProducerConsumerCollection<T> collection)
- public static IEnumerable<T> Prepend<T>(this IEnumerable<T> collection, T[] items)
- public static int SequenceHashCode<T>(this IEnumerable<T> sequence, bool salted = true)
- public static IEnumerable<T> SkipNulls<T>(this IEnumerable<T> collection)
- public static IAsyncEnumerable<T> ToAsyncEnumerable<T>(this IEnumerable<T> enumerable)
- public static string ToString<T>(this IEnumerable<T> collection, string delimiter, string ifEmpty = "")
public static class 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 Enumerator
- public struct LimitedEnumerator<T> : IEnumerator<T>, IEnumerator, IDisposable
- public static IAsyncEnumerator<T> GetAsyncEnumerator<T>(this IEnumerable<T> enumerable, CancellationToken token = default)
- public static LimitedEnumerator<T> Limit<T>(this IEnumerator<T> enumerator, int count, bool leaveOpen = false)
- public static bool Skip<T>(this IEnumerator<T> enumerator, int count)
- public static bool Skip<TEnumerator, T>(this ref TEnumerator enumerator, int count) where TEnumerator : struct, IEnumerator<T>
- public static IEnumerator<T> ToEnumerator<T>(ReadOnlyMemory<T> memory)
- public static IEnumerator<T> ToEnumerator<T>(ref ReadOnlySequence sequence)
public static class List
- public static ReadOnlyListView<T> AsReadOnlyView<T>(this IList<T> list)
- public static ReadOnlyListView<I, O> Convert<I, O>(this IReadOnlyList 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 input, Converter<I, O> mapper)
- public static O[] ToArray<I, O>(this IList 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 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 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 Set
- public static IReadOnlySet<T> Range<T, TLowerBound, TUpperBound>(TLowerBound lowerBound, TUpperBound upperBound) where T : IBinaryInteger<T> where TLowerBound : IFiniteRangeEndpoint<T> where TUpperBound : IFiniteRangeEndpoint<T>
- public static IReadOnlySet<T> Singleton<T>(T item)

DotNext.Collections.Specialized

public class ConcurrentTypeMap : ITypeMap, IReadOnlyTypeMap
- public ConcurrentTypeMap(int capacity)
- public ConcurrentTypeMap()
- public bool AddOrUpdate<T>(T value)
- public void Clear()
- public bool Contains<T>()
- public T GetOrAdd<T>(T value, out bool added)
- public bool Remove<T>()
- public bool Remove<T>(out T value)
- public void Set<T>(T value)
- public bool Set<T>(T newValue, out T oldValue)
- public bool TryAdd<T>(T value)
- public bool TryGetValue<T>(out T value)
public class ConcurrentTypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>
- public struct Enumerator<TValue>
- public ConcurrentTypeMap(int capacity)
- public ConcurrentTypeMap()
- public bool AddOrUpdate<TKey>(TValue value)
- public void Clear()
- public bool ContainsKey<TKey>()
- public Enumerator<TValue> GetEnumerator()
- public TValue GetOrAdd<TKey>(TValue value, out bool added)
- public bool Remove<TKey>(out TValue value)
- public bool Remove<TKey>()
- public void Set<TKey>(TValue value)
- public bool Set<TKey>(TValue newValue, out TValue oldValue)
- public bool TryAdd<TKey>(TValue value)
- public bool TryGetValue<TKey>(out TValue value)
public static class InvocationList
- public static void Invoke<T>(this InvocationList<Action<T>> actions, T arg)
- public static void Invoke<T1, T2>(this InvocationList<Action<T1, T2>> actions, T1 arg1, T2 arg2)
public struct InvocationList<TDelegate> : IReadOnlyList<TDelegate>, IEnumerable<TDelegate>, IEnumerable, IReadOnlyCollection<TDelegate> where TDelegate : MulticastDelegate
- public struct Enumerator<TDelegate> where TDelegate : MulticastDelegate
- public static InvocationList<TDelegate> Empty { get; }
- public int Count { get; }
- public bool IsEmpty { get; }
- public TDelegate this[int index] { get; }
- public ReadOnlySpan<TDelegate> Span { get; }
- public InvocationList(TDelegate d)
- public static InvocationList<TDelegate> op_Addition(InvocationList<TDelegate> list, TDelegate d)
- public static InvocationList<TDelegate> op_Subtraction(InvocationList<TDelegate> list, TDelegate d)
- public InvocationList<TDelegate> Add(TDelegate d)
- public TDelegate Combine()
- public Enumerator<TDelegate> GetEnumerator()
- public InvocationList<TDelegate> Remove(TDelegate d)
public interface IReadOnlyTypeMap
- bool Contains<T>()
- bool TryGetValue<T>(out T value)
public interface IReadOnlyTypeMap<TValue>
- bool ContainsKey<TKey>()
- bool TryGetValue<TKey>(out TValue value)
public interface ITypeMap : IReadOnlyTypeMap
- void Add<T>(T value)
- void Clear()
- bool Remove<T>()
- bool Remove<T>(out T value)
- void Set<T>(T value)
- bool Set<T>(T newValue, out T oldValue)
public interface ITypeMap<TValue> : IReadOnlyTypeMap<TValue>
- void Add<TKey>(TValue value)
- void Clear()
- bool Remove<TKey>()
- bool Remove<TKey>(out TValue value)
- void Set<TKey>(TValue value)
- bool Set<TKey>(TValue newValue, out TValue oldValue)
public struct SingletonList<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IList<T>, ICollection<T>, ITuple, IReadOnlySet<T>
- public struct Enumerator<T> : IEnumerator<T>, IEnumerator, IDisposable
- public T Item
- public T this[int index] { get; set; }
- public static SingletonList<T> op_Implicit(T item)
- public Enumerator<T> GetEnumerator()
public class TypeMap : ITypeMap, IReadOnlyTypeMap
- public TypeMap(int capacity)
- public TypeMap()
- public void Add<T>(T value)
- public void Clear()
- public bool Contains<T>()
- public ref T GetValueRefOrAddDefault<T>(out bool exists) where T : struct
- public bool Remove<T>()
- public bool Remove<T>(out T value)
- public void Set<T>(T value)
- public bool Set<T>(T newValue, out T oldValue)
- public bool TryGetValue<T>(out T value)
public class TypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>
- public struct Enumerator<TValue>
- public TypeMap(int capacity)
- public TypeMap()
- public void Add<TKey>(TValue value)
- public void Clear()
- public bool ContainsKey<TKey>()
- public Enumerator<TValue> GetEnumerator()
- public ref TValue GetValueRefOrAddDefault<TKey>(out bool exists)
- public bool Remove<TKey>()
- public bool Remove<TKey>(out TValue value)
- public void Set<TKey>(TValue value)
- public bool Set<TKey>(TValue newValue, out TValue oldValue)
- public bool TryGetValue<TKey>(out TValue value)

DotNext.ComponentModel.DataAnnotations

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

DotNext.Diagnostics

public struct Timestamp : IEquatable<Timestamp>, IComparable<Timestamp>, IComparisonOperators<Timestamp, Timestamp, bool>, IEqualityOperators<Timestamp, Timestamp, bool>, IAdditionOperators<Timestamp, TimeSpan, Timestamp>, ISubtractionOperators<Timestamp, TimeSpan, Timestamp>, IInterlockedOperations<Timestamp>
- public TimeSpan Elapsed { get; }
- public double ElapsedMilliseconds { get; }
- public long ElapsedTicks { get; }
- public bool IsEmpty { get; }
- public bool IsFuture { get; }
- public bool IsPast { get; }
- public TimeSpan Value { get; }
- public Timestamp()
- public Timestamp(TimeSpan ts)
- public static Timestamp CompareExchange(ref Timestamp location, Timestamp value, Timestamp comparand)
- public static Timestamp op_Addition(Timestamp x, TimeSpan y)
- public static Timestamp op_CheckedAddition(Timestamp x, TimeSpan y)
- public static Timestamp op_CheckedSubtraction(Timestamp x, TimeSpan y)
- public static bool op_Equality(Timestamp left, Timestamp right)
- public static TimeSpan op_Explicit(Timestamp stamp)
- public static bool op_GreaterThan(Timestamp first, Timestamp second)
- public static bool op_GreaterThanOrEqual(Timestamp first, Timestamp second)
- public static bool op_Inequality(Timestamp left, Timestamp right)
- public static bool op_LessThan(Timestamp first, Timestamp second)
- public static bool op_LessThanOrEqual(Timestamp first, Timestamp second)
- public static Timestamp op_Subtraction(Timestamp x, TimeSpan y)
- public static void Refresh(ref Timestamp location)
- public static Timestamp VolatileRead(ref Timestamp location)
- public static void VolatileWrite(ref Timestamp location, Timestamp newValue)
- public int CompareTo(Timestamp other)
- public double ElapsedSince(Timestamp past)
- public bool Equals(Timestamp other)

DotNext.Generic

public abstract class BooleanConst : Constant<bool>
public abstract class Constant<T>
public abstract class IntConst : Constant<int>
public abstract class LongConst : Constant<long>
public abstract class StringConst : Constant<string>

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>, IFunctional<Func<ReadOnlyMemory<byte>, CancellationToken, ValueTask>>, IEquatable<StreamConsumer>, IFlushable
- public bool IsEmpty { get; }
- public StreamConsumer(Stream output)
- public static bool op_Equality(StreamConsumer left, StreamConsumer right)
- public static StreamConsumer op_Implicit(Stream output)
- public static bool op_Inequality(StreamConsumer left, StreamConsumer right)
- public void Deconstruct(out Stream output)
- 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 AsStream<TArg>(this Func<Memory<byte>, TArg, CancellationToken, ValueTask<int>> reader, TArg arg)
- public static Stream AsSynchronousStream<TOutput>(TOutput output) where TOutput : IFlushable, IReadOnlySpanConsumer<byte>
public struct TextConsumer : IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IFlushable, IEquatable<TextConsumer>
- public bool IsEmpty { get; }
- public TextConsumer(TextWriter output)
- public static bool op_Equality(TextConsumer left, TextConsumer right)
- public static TextConsumer op_Implicit(TextWriter output)
- public static bool op_Inequality(TextConsumer left, TextConsumer right)
- public void Deconstruct(out TextWriter output)
- public bool Equals(TextConsumer other)

DotNext.IO.Hashing

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

DotNext.Net.Http

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

DotNext.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.Numerics

public static class Number
- public static TResult FromBits<TResult>(this ReadOnlySpan<bool> bits) where TResult : struct, IBinaryInteger<TResult>
- public static void GetBits<T>(this T value, Span<bool> bits) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), IBinaryInteger<T>
- public static int GetMaxByteCount<T>() where T : IBinaryInteger<T>
- public static bool IsSigned<T>() where T : INumberBase<T>
- public static TOutput Normalize<TInput, TOutput>(this TInput value, TInput min, TInput max) where TInput : struct, INumberBase<TInput>, IComparisonOperators<TInput, TInput, bool> where TOutput : struct, IFloatingPoint<TOutput>
- public static double Normalize(this ulong value)
- public static double Normalize(this long value)
- public static float Normalize(this uint value)
- public static float Normalize(this int value)

DotNext.Patterns

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

DotNext.Reflection

public static class 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 PropertyExtensions
- public static bool IsExternalInit(this PropertyInfo property)
public static class TaskType
- public static Func<Task, bool> IsCompletedSuccessfullyGetter { get; }
- public static Func<bool> GetIsCompletedGetter(this Task task)
- public static Func<Task<T>, T> GetResultGetter<T>()
- public static Type MakeTaskType(this Type taskResult, bool valueTask)
public static class TypeExtensions
- public static MethodInfo Devirtualize(this Type type, MethodInfo abstractMethod)
- public static IEnumerable<Type> GetBaseTypes(this Type type, bool includeTopLevel = false, bool includeInterfaces = false)
- public static object GetDefaultValue(this Type type)
- 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)
- public static bool IsUnmanaged(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 abstract class BoxedValue<T> where T : struct
- public ref T Value { get; }
- public static BoxedValue<T> Box(T value)
- public static BoxedValue<T> GetTypedReference(object boxedValue)
- public static BoxedValue<T> op_Explicit(T value)
- public static BoxedValue<T> op_Explicit(ref Nullable value)
- public static T op_Implicit(BoxedValue<T> boxedValue)
- public static ValueType op_Implicit(BoxedValue<T> boxedValue)
- public static BoxedValue<T> TryBox(ref Nullable value)
- public BoxedValue<T> Copy()
- public abstract bool Equals(object obj)
- public abstract int GetHashCode()
- public abstract string ToString()
public struct GCLatencyModeScope : IDisposable
- public static GCLatencyModeScope LowLatency { get; }
- public static GCLatencyModeScope SustainedLowLatency { get; }
- public GCLatencyModeScope(GCLatencyMode mode)
- public void Dispose()
public abstract class GCNotification
- public struct Registration : IDisposable
- public static GCNotification GCTriggered()
- public static GCNotification GCTriggered(int generation)
- public static GCNotification HeapCompaction()
- public static GCNotification HeapFragmentation(double threshold)
- public static GCNotification MemoryThreshold(double threshold)
- public static GCNotification op_BitwiseAnd(GCNotification left, GCNotification right)
- public static GCNotification op_BitwiseOr(GCNotification left, GCNotification right)
- public static GCNotification op_ExclusiveOr(GCNotification left, GCNotification right)
- public static GCNotification op_LogicalNot(GCNotification filter)
- public virtual GCNotification And(GCNotification right)
- public virtual GCNotification ExclusiveOr(GCNotification right)
- public virtual GCNotification Negate()
- public virtual GCNotification Or(GCNotification right)
- public Registration Register<T>(Action<T, GCMemoryInfo> callback, T state, bool captureContext = false)
- public Task<GCMemoryInfo> WaitAsync(TimeSpan timeout, CancellationToken token = default)
- public Task<GCMemoryInfo> WaitAsync(CancellationToken token = default)
public static class Intrinsics
- public static IntPtr AddressOf<T>(ref T value)
- public static int AlignOf<T>()
- public static bool AreCompatible<T1, T2>()
- public static ref T AsRef<T>(this TypedReference reference)
- public static T Cast<T>(object obj)
- public static int Compare(Void* first, Void* second, UIntPtr 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, UIntPtr 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 bool Equals(Void* first, Void* second, UIntPtr length)
- public static UIntPtr GetLength(this Array array)
- public static bool HasFinalizer(object obj)
- 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 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 RuntimeTypeHandle TypeOf<T>()
public sealed class SoftReference<T> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>
- public ValueTuple<T, SoftReferenceState> TargetAndState { get; }
- public SoftReference(T target, SoftReferenceOptions options = null)
- public static T op_Explicit(SoftReference<T> reference)
- public static Optional<T> op_Explicit(SoftReference<T> reference)
- public void Clear()
- public bool TryGetTarget(out T target)
- public Optional<T> TryGetTarget()
public class SoftReferenceOptions
- public static SoftReferenceOptions Default { get; }
- public int CollectionCount { get; set; }
- public long MemoryLimit { get; set; }
- public double MemoryThreshold { get; set; }
- public SoftReferenceOptions()
public enum SoftReferenceState
- Empty = 0
- Strong = 2
- Weak = 1

DotNext.Runtime.Caching

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

DotNext.Runtime.CompilerServices

public interface IFunctional<TDelegate> where TDelegate : Delegate
- TDelegate ToDelegate()
public struct Scope : IDisposable, IAsyncDisposable
- public void Defer(Action callback)
- public void Defer(Func<ValueTask> callback)
- public void Dispose()
- public ValueTask DisposeAsync()
- public void RegisterForDispose(IDisposable disposable)
- public void RegisterForDisposeAsync(IAsyncDisposable disposable)
public struct SpawningAsyncTaskMethodBuilder
- public Task Task { get; }
- public SpawningAsyncTaskMethodBuilder()
- public static SpawningAsyncTaskMethodBuilder Create()
- public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
- public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
- public void SetException(Exception e)
- public void SetResult()
- public void SetStateMachine(IAsyncStateMachine stateMachine)
- public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
public struct SpawningAsyncTaskMethodBuilder<TResult>
- public Task<TResult> Task { get; }
- public SpawningAsyncTaskMethodBuilder()
- public static SpawningAsyncTaskMethodBuilder<TResult> Create()
- public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
- public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
- public void SetException(Exception e)
- public void SetResult(TResult result)
- public void SetStateMachine(IAsyncStateMachine stateMachine)
- public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine

DotNext.Runtime.ExceptionServices

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

DotNext.Runtime.InteropServices

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

DotNext.Text

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)
public static class InterpolatedString
- public static MemoryOwner<char> Interpolate(MemoryAllocator<char> allocator, IFormatProvider provider, ref PoolingInterpolatedStringHandler handler)
- public static MemoryOwner<char> Interpolate(MemoryAllocator<char> allocator, ref PoolingInterpolatedStringHandler handler)
public struct StringBuilderConsumer : IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IEquatable<StringBuilderConsumer>
- public bool IsEmpty { get; }
- public StringBuilderConsumer(StringBuilder builder)
- public static bool op_Equality(StringBuilderConsumer left, StringBuilderConsumer right)
- public static StringBuilderConsumer op_Implicit(StringBuilder builder)
- public static bool op_Inequality(StringBuilderConsumer left, StringBuilderConsumer right)
- public bool Equals(StringBuilderConsumer other)

DotNext.Text.Json

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

DotNext.Threading

public static class AsyncDelegate
public struct AtomicBoolean : IEquatable<bool>
public static class AtomicDouble
public static class AtomicFloat
public static class AtomicInteger
public static class AtomicLong
public static class AtomicReference
public struct AtomicReference<T> : IEquatable<T>
public class ConcurrentObjectPool<T>
public static class Atomic
- public struct Boolean : IEquatable<bool>
- public static double AccumulateAndGet<TAccumulator>(ref double value, double x, TAccumulator accumulator) where TAccumulator : ISupplier<double, double, double>
- public static double AccumulateAndGet(ref double value, double x, Func<double, double, double> accumulator)
- public static IntPtr AccumulateAndGet<TAccumulator>(ref IntPtr value, IntPtr x, TAccumulator accumulator) where TAccumulator : ISupplier<IntPtr, IntPtr, IntPtr>
- public static IntPtr AccumulateAndGet(ref IntPtr value, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
- public static int AccumulateAndGet<TAccumulator>(ref int value, int x, TAccumulator accumulator) where TAccumulator : ISupplier<int, int, int>
- public static int AccumulateAndGet(ref int value, int x, Func<int, int, int> accumulator)
- public static long AccumulateAndGet<TAccumulator>(ref long value, long x, TAccumulator accumulator) where TAccumulator : ISupplier<long, long, long>
- public static long AccumulateAndGet(ref long value, long x, Func<long, long, long> accumulator)
- public static float AccumulateAndGet<TAccumulator>(ref float value, float x, TAccumulator accumulator) where TAccumulator : ISupplier<float, float, float>
- public static float AccumulateAndGet(ref float value, float x, Func<float, float, float> accumulator)
- public static UIntPtr AccumulateAndGet<TAccumulator>(ref UIntPtr value, UIntPtr x, TAccumulator accumulator) where TAccumulator : ISupplier<UIntPtr, UIntPtr, UIntPtr>
- public static UIntPtr AccumulateAndGet(ref UIntPtr value, UIntPtr x, Func<UIntPtr, UIntPtr, UIntPtr> accumulator)
- public static uint AccumulateAndGet<TAccumulator>(ref uint value, uint x, TAccumulator accumulator) where TAccumulator : ISupplier<uint, uint, uint>
- public static uint AccumulateAndGet(ref uint value, uint x, Func<uint, uint, uint> accumulator)
- public static ulong AccumulateAndGet<TAccumulator>(ref ulong value, ulong x, TAccumulator accumulator) where TAccumulator : ISupplier<ulong, ulong, ulong>
- public static ulong AccumulateAndGet(ref ulong value, ulong x, Func<ulong, ulong, ulong> accumulator)
- public static double GetAndAccumulate<TAccumulator>(ref double value, double x, TAccumulator accumulator) where TAccumulator : ISupplier<double, double, double>
- public static double GetAndAccumulate(ref double value, double x, Func<double, double, double> accumulator)
- public static IntPtr GetAndAccumulate<TAccumulator>(ref IntPtr value, IntPtr x, TAccumulator accumulator) where TAccumulator : ISupplier<IntPtr, IntPtr, IntPtr>
- public static IntPtr GetAndAccumulate(ref IntPtr value, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
- public static int GetAndAccumulate<TAccumulator>(ref int value, int x, TAccumulator accumulator) where TAccumulator : ISupplier<int, int, int>
- public static int GetAndAccumulate(ref int value, int x, Func<int, int, int> accumulator)
- public static long GetAndAccumulate<TAccumulator>(ref long value, long x, TAccumulator accumulator) where TAccumulator : ISupplier<long, long, long>
- public static long GetAndAccumulate(ref long value, long x, Func<long, long, long> accumulator)
- public static float GetAndAccumulate<TAccumulator>(ref float value, float x, TAccumulator accumulator) where TAccumulator : ISupplier<float, float, float>
- public static float GetAndAccumulate(ref float value, float x, Func<float, float, float> accumulator)
- public static UIntPtr GetAndAccumulate<TAccumulator>(ref UIntPtr value, UIntPtr x, TAccumulator accumulator) where TAccumulator : ISupplier<UIntPtr, UIntPtr, UIntPtr>
- public static UIntPtr GetAndAccumulate(ref UIntPtr value, UIntPtr x, Func<UIntPtr, UIntPtr, UIntPtr> accumulator)
- public static uint GetAndAccumulate<TAccumulator>(ref uint value, uint x, TAccumulator accumulator) where TAccumulator : ISupplier<uint, uint, uint>
- public static uint GetAndAccumulate(ref uint value, uint x, Func<uint, uint, uint> accumulator)
- public static ulong GetAndAccumulate<TAccumulator>(ref ulong value, ulong x, TAccumulator accumulator) where TAccumulator : ISupplier<ulong, ulong, ulong>
- public static ulong GetAndAccumulate(ref ulong value, ulong x, Func<ulong, ulong, ulong> accumulator)
- public static double GetAndUpdate<TUpdater>(ref double value, TUpdater updater) where TUpdater : ISupplier<double, double>
- public static double GetAndUpdate(ref double value, Func<double, double> updater)
- public static IntPtr GetAndUpdate<TUpdater>(ref IntPtr value, TUpdater updater) where TUpdater : ISupplier<IntPtr, IntPtr>
- public static IntPtr GetAndUpdate(ref IntPtr value, Func<IntPtr, IntPtr> updater)
- public static int GetAndUpdate<TUpdater>(ref int value, TUpdater updater) where TUpdater : ISupplier<int, int>
- public static int GetAndUpdate(ref int value, Func<int, int> updater)
- public static long GetAndUpdate<TUpdater>(ref long value, TUpdater updater) where TUpdater : ISupplier<long, long>
- public static long GetAndUpdate(ref long value, Func<long, long> updater)
- public static float GetAndUpdate<TUpdater>(ref float value, TUpdater updater) where TUpdater : ISupplier<float, float>
- public static float GetAndUpdate(ref float value, Func<float, float> updater)
- public static UIntPtr GetAndUpdate<TUpdater>(ref UIntPtr value, TUpdater updater) where TUpdater : ISupplier<UIntPtr, UIntPtr>
- public static UIntPtr GetAndUpdate(ref UIntPtr value, Func<UIntPtr, UIntPtr> updater)
- public static uint GetAndUpdate<TUpdater>(ref uint value, TUpdater updater) where TUpdater : ISupplier<uint, uint>
- public static uint GetAndUpdate(ref uint value, Func<uint, uint> updater)
- public static ulong GetAndUpdate<TUpdater>(ref ulong value, TUpdater updater) where TUpdater : ISupplier<ulong, ulong>
- public static ulong GetAndUpdate(ref ulong value, Func<ulong, ulong> updater)
- public static bool IsAtomic<T>()
- public static double UpdateAndGet<TUpdater>(ref double value, TUpdater updater) where TUpdater : ISupplier<double, double>
- public static double UpdateAndGet(ref double value, Func<double, double> updater)
- public static IntPtr UpdateAndGet<TUpdater>(ref IntPtr value, TUpdater updater) where TUpdater : ISupplier<IntPtr, IntPtr>
- public static IntPtr UpdateAndGet(ref IntPtr value, Func<IntPtr, IntPtr> updater)
- public static int UpdateAndGet<TUpdater>(ref int value, TUpdater updater) where TUpdater : ISupplier<int, int>
- public static int UpdateAndGet(ref int value, Func<int, int> updater)
- public static long UpdateAndGet<TUpdater>(ref long value, TUpdater updater) where TUpdater : ISupplier<long, long>
- public static long UpdateAndGet(ref long value, Func<long, long> updater)
- public static float UpdateAndGet<TUpdater>(ref float value, TUpdater updater) where TUpdater : ISupplier<float, float>
- public static float UpdateAndGet(ref float value, Func<float, float> updater)
- public static UIntPtr UpdateAndGet<TUpdater>(ref UIntPtr value, TUpdater updater) where TUpdater : ISupplier<UIntPtr, UIntPtr>
- public static UIntPtr UpdateAndGet(ref UIntPtr value, Func<UIntPtr, UIntPtr> updater)
- public static uint UpdateAndGet<TUpdater>(ref uint value, TUpdater updater) where TUpdater : ISupplier<uint, uint>
- public static uint UpdateAndGet(ref uint value, Func<uint, uint> updater)
- public static ulong UpdateAndGet<TUpdater>(ref ulong value, TUpdater updater) where TUpdater : ISupplier<ulong, ulong>
- public static ulong UpdateAndGet(ref ulong value, Func<ulong, ulong> updater)
public struct 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 interface IInterlockedOperations<T>
- T CompareExchange(ref T location, T value, T comparand)
- T VolatileRead(T& modreq(System.Runtime.InteropServices.InAttribute) location)
- void VolatileWrite(ref T location, T value)
public struct Lock : IDisposable, IEquatable<Lock>
- public struct Holder
- public static Lock ReadLock(ReaderWriterLockSlim rwLock)
- public static Lock ReadLock(ReaderWriterLockSlim rwLock, bool upgradeable)
- public static Lock UpgradableReadLock(ReaderWriterLockSlim rwLock)
- public static Lock Semaphore(int initialCount, int maxCount)
- public void Acquire()
- public Holder Acquire()
- public Holder Acquire(TimeSpan timeout)
- public bool Equals(ref Lock other)
- public bool TryAcquire()
- public bool TryAcquire(TimeSpan timeout)
- public bool Equals(Lock other)
- public bool TryAcquire(out Holder holder)
- public bool TryAcquire(TimeSpan timeout, out Holder holder)
public static class LockAcquisition
- public static Lock Lock<T>(this T obj)
- public static Lock Lock<T>(this T obj, TimeSpan timeout)
- public static Lock Lock(this SemaphoreSlim semaphore)
- public static Lock Lock(this SemaphoreSlim semaphore, TimeSpan timeout)
- public static Lock ReadLock(this ReaderWriterLockSlim rwLock)
- public static Lock ReadLock(this ReaderWriterLockSlim rwLock, TimeSpan timeout)
- public static Lock UpgradableReadLock(this ReaderWriterLockSlim rwLock)
- public static Lock UpgradableReadLock(this ReaderWriterLockSlim rwLock, TimeSpan timeout)
- public static Lock WriteLock(this ReaderWriterLockSlim rwLock)
- public static Lock WriteLock(this ReaderWriterLockSlim rwLock, TimeSpan timeout)
- public static Holder AcquireReadLock<T>(this T obj)
- public static Holder AcquireReadLock<T>(this T obj, TimeSpan timeout)
- public static Holder AcquireUpgradeableReadLock<T>(this T obj)
- public static Holder AcquireUpgradeableReadLock<T>(this T obj, TimeSpan timeout)
- public static Holder AcquireWriteLock<T>(this T obj)
- public static Holder AcquireWriteLock<T>(this T obj, TimeSpan timeout)
public struct ReaderWriterSpinLock
- public struct LockStamp : IEquatable<LockStamp>
- public int CurrentReadCount { get; }
- public bool IsReadLockHeld { get; }
- public bool IsWriteLockHeld { get; }
- public void DowngradeFromWriteLock()
- 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 TryUpgradeToWriteLock()
- public bool TryUpgradeToWriteLock(TimeSpan timeout, CancellationToken token = default)
- public void UpgradeToWriteLock()
- 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 const long InfiniteTicks = -10000
- public static Timeout Expired { get; }
- public static Timeout Infinite { get; }
- public bool IsExpired { get; }
- public bool IsInfinite { get; }
- public TimeSpan Value { get; }
- public void ThrowIfExpired(out TimeSpan remainingTime)
- public bool TryGetRemainingTime(out TimeSpan remainingTime)

DotNext.Threading.Tasks

public static class Conversion
- public static Task<O> Convert<I, O>(this Task task, Converter<I, O> converter)
- public static Task<O> Convert<I, O>(this Task 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 : ICriticalNotifyCompletion, INotifyCompletion
- public DynamicTaskAwaitable ConfigureAwait(bool continueOnCapturedContext)
- public Awaiter GetAwaiter()
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 Task<ValueTuple<T1, T2>> WhenAll<T1, T2>(Task<T1> task1, Task<T2> task2)
- public static Task<ValueTuple<T1, T2, T3>> WhenAll<T1, T2, T3>(Task<T1> task1, Task<T2> task2, Task<T3> task3)
- public static Task<ValueTuple<T1, T2, T3, T4>> WhenAll<T1, T2, T3, T4>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4)
- public static Task<ValueTuple<T1, T2, T3, T4, T5>> WhenAll<T1, T2, T3, T4, T5>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4, Task<T5> task5)
- public static Result<TResult> 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 Result<TResult>? TryGetResult<TResult>(this Task<TResult> task)
- public static Task<ValueTuple<Result<T1>, Result<T2>>> WhenAll<T1, T2>(Task<T1> task1, Task<T2> task2)
- public static Task<ValueTuple<Result<T1>, Result<T2>, Result<T3>>> WhenAll<T1, T2, T3>(Task<T1> task1, Task<T2> task2, Task<T3> task3)
- public static Task<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>>> WhenAll<T1, T2, T3, T4>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4)
- public static Task<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>, Result<T5>>> WhenAll<T1, T2, T3, T4, T5>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4, Task<T5> task5)
- public static ValueTask WhenAll(ValueTask task1, ValueTask task2)
- public static ValueTask<ValueTuple<Result<T1>, Result<T2>>> WhenAll<T1, T2>(ValueTask<T1> task1, ValueTask<T2> task2)
- public static ValueTask WhenAll(ValueTask task1, ValueTask task2, ValueTask task3)
- public static ValueTask<ValueTuple<Result<T1>, Result<T2>, Result<T3>>> WhenAll<T1, T2, T3>(ValueTask<T1> task1, ValueTask<T2> task2, ValueTask<T3> task3)
- public static ValueTask WhenAll(ValueTask task1, ValueTask task2, ValueTask task3, ValueTask task4)
- public static ValueTask<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>>> WhenAll<T1, T2, T3, T4>(ValueTask<T1> task1, ValueTask<T2> task2, ValueTask<T3> task3, ValueTask<T4> task4)
- public static ValueTask WhenAll(ValueTask task1, ValueTask task2, ValueTask task3, ValueTask task4, ValueTask task5)
- public static ValueTask<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>, Result<T5>>> WhenAll<T1, T2, T3, T4, T5>(ValueTask<T1> task1, ValueTask<T2> task2, ValueTask<T3> task3, ValueTask<T4> task4, ValueTask<T5> task5)

DotNext.VariantType

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