DotNext by Roman Sakno

API Diff between 2.9.1 and 5.14.0

979 Additions 367 Removals

DotNext

public struct Activator<T> : ISupplier<T>, IFunctional<Func<T>>
public static class BasicExtensions
public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : struct
- public static int GetHashCode(ref T value, int hash, ref ValueFunc hashFunction, bool salted)
- public static int GetHashCode(ref T value, int hash, Func<int, int, int> hashFunction, bool salted = true)
public enum BoundType
- Closed = 3
- LeftClosed = 1
- Open = 0
- RightClosed = 2
public abstract class CharComparer : IEqualityComparer<char>, IComparer<char>
public struct Consumer<T> : IConsumer<T>, IFunctional<Action<T>>
public struct ConsumerClosure<TContext, T> : IConsumer<T>, IFunctional<Action<T>>
public static class Comparison
- public static ValueFunc<T, T, int> AsValueFunc<T>(this Comparison<T> comparison, bool wrap = false)
- public static bool Between<T>(this T value, T left, T right, BoundType boundType = 0) where T : IComparable<T>
- public static T Clamp<T>(this T value, T min, T max) where T : IComparable<T>
public static class Converter
- public static ValueFunc<TInput, TOutput> AsValueFunc<TInput, TOutput>(this Converter<TInput, TOutput> converter, bool wrap = false)
public static class DelegateHelpers
- public static Func<bool> Bind<T>(this Predicate<T> predicate, T obj)
- 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 CreateDelegate<TDelegate>(this MethodInfo method, object target = null) where TDelegate : Delegate
- public static Action HideReturnValue<TResult>(this Func<TResult> func)
- public static Action<T> HideReturnValue<T, TResult>(this Func<T, TResult> func)
- public static Func<T, CancellationToken, ValueTask> ToAsync<T>(this Action<T> action)
- public static Func<T, CancellationToken, ValueTask<TResult>> ToAsync<T, TResult>(this Func<T, TResult> action)
- public static Func<CancellationToken, ValueTask> ToAsync(this Action action)
- public static Func<CancellationToken, ValueTask<TResult>> ToAsync<TResult>(this Func<TResult> func)
- public static Func<T1, T2, CancellationToken, ValueTask> ToAsync<T1, T2>(this Action<T1, T2> action)
- public static Func<T1, T2, CancellationToken, ValueTask<TResult>> ToAsync<T1, T2, TResult>(this Func<T1, T2, TResult> func)
- public static Predicate<T> Unbind<T>(this Func<bool> func)
public struct DelegatingConsumer<T> : IConsumer<T>, IFunctional<Action<T>>, IEquatable<DelegatingConsumer<T>>
public struct DelegatingSupplier<TResult> : ISupplier<TResult>, IFunctional<Func<TResult>>, IEquatable<DelegatingSupplier<TResult>>
public struct DelegatingSupplier<T, TResult> : ISupplier<T, TResult>, IFunctional<Func<T, TResult>>, IEquatable<DelegatingSupplier<T, TResult>>
public struct DelegatingSupplier<T1, T2, TResult> : ISupplier<T1, T2, TResult>, IFunctional<Func<T1, T2, TResult>>, IEquatable<DelegatingSupplier<T1, T2, TResult>>
public struct DisclosedEndpoint<T> : IFiniteRangeEndpoint<T>, IRangeEndpoint<T> where T : IComparable<T>
public abstract class Disposable : IDisposable
- protected bool IsDisposing { get; }
- protected bool IsDisposingOrDisposed { get; }
- public static void Dispose(ReadOnlySpan<IDisposable> objects)
- public static void Dispose(IDisposable[] objects)
- protected static void QueueDispose(IDisposable resource)
- protected ValueTask DisposeAsync()
- protected virtual ValueTask DisposeAsyncCore()
- protected bool TryBeginDispose()
- protected void ThrowIfDisposed()
- protected bool TrySetDisposedException(TaskCompletionSource source)
public struct EnclosedEndpoint<T> : IFiniteRangeEndpoint<T>, IRangeEndpoint<T> where T : IComparable<T>
public struct Enum<TEnum> : IEquatable<TEnum>, IComparable<TEnum>, IFormattable, IEquatable<Enum<TEnum>>, ISerializable, IConvertible<TEnum> where TEnum : struct, Enum
- public static readonly Enum<TEnum> MaxValue
- public static readonly Enum<TEnum> MinValue
- public static IReadOnlyList<Enum<TEnum>> Members { get; }
- public static Type UnderlyingType { get; }
- public static TypeCode UnderlyingTypeCode { get; }
- public string Name { get; }
- public TEnum Value { get; }
- public static Enum<TEnum> GetMember(TEnum value)
- public static Enum<TEnum> GetMember(string name)
- public static bool IsDefined(TEnum value)
- public static bool IsDefined(string name)
- public static bool op_Equality(Enum<TEnum> first, Enum<TEnum> second)
- public static TEnum op_Implicit(ref Enum en)
- public static bool op_Inequality(Enum<TEnum> first, Enum<TEnum> second)
- public static bool TryGetMember(TEnum value, out Enum member)
- public static bool TryGetMember(string name, out Enum member)
- public int CompareTo(TEnum other)
- public bool Equals(TEnum other)
- public bool Equals(Enum<TEnum> other)
- public bool IsFlag(TEnum flags)
public static class EnumConverter
- public static TValue FromEnum<TEnum, TValue>(TEnum value) where TEnum : struct, Enum where TValue : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), INumberBase<TValue>, IConvertible
- public static TypeCode GetTypeCode<TEnum>() where TEnum : struct, Enum
- public static TEnum ToEnum<TEnum, TValue>(TValue value) where TEnum : struct, Enum where TValue : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), INumberBase<TValue>, IConvertible
- public static bool IsOneOf<T>(this T value, T[] values) where T : struct, Enum
- public static byte ToByte<T>(this T value) where T : struct, Enum
- public static T ToEnum<T>(this long value) where T : struct, Enum
- public static T ToEnum<T>(this int value) where T : struct, Enum
- public static T ToEnum<T>(this short value) where T : struct, Enum
- public static T ToEnum<T>(this byte value) where T : struct, Enum
- public static T ToEnum<T>(this sbyte value) where T : struct, Enum
- public static T ToEnum<T>(this ushort value) where T : struct, Enum
- public static T ToEnum<T>(this uint value) where T : struct, Enum
- public static T ToEnum<T>(this ulong value) where T : struct, Enum
- public static short ToInt16<T>(this T value) where T : struct, Enum
- public static int ToInt32<T>(this T value) where T : struct, Enum
- public static long ToInt64<T>(this T value) where T : struct, Enum
- public static sbyte ToSByte<T>(this T value) where T : struct, Enum
- public static ushort ToUInt16<T>(this T value) where T : struct, Enum
- public static uint ToUInt32<T>(this T value) where T : struct, Enum
- public static ulong ToUInt64<T>(this T value) where T : struct, Enum
public static class EnumerableTuple
- public static EnumerableTuple<T, ValueTuple<T>> AsEnumerable<T>(this ValueTuple<T> tuple)
- public static EnumerableTuple<T, Tuple<T>> AsEnumerable<T>(this Tuple<T> tuple)
- public static EnumerableTuple<T, ValueTuple<T, T>> AsEnumerable<T>(this ValueTuple<T, T> tuple)
- public static EnumerableTuple<T, Tuple<T, T>> AsEnumerable<T>(this Tuple<T, T> tuple)
- public static EnumerableTuple<T, ValueTuple<T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T> tuple)
- public static EnumerableTuple<T, Tuple<T, T, T>> AsEnumerable<T>(this Tuple<T, T, T> tuple)
- public static EnumerableTuple<T, ValueTuple<T, T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T, T> tuple)
- public static EnumerableTuple<T, Tuple<T, T, T, T>> AsEnumerable<T>(this Tuple<T, T, T, T> tuple)
- public static EnumerableTuple<T, ValueTuple<T, T, T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T, T, T> tuple)
- public static EnumerableTuple<T, Tuple<T, T, T, T, T>> AsEnumerable<T>(this Tuple<T, T, T, T, T> tuple)
- public static EnumerableTuple<T, ValueTuple<T, T, T, T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T, T, T, T> tuple)
- public static EnumerableTuple<T, Tuple<T, T, T, T, T, T>> AsEnumerable<T>(this Tuple<T, T, T, T, T, T> tuple)
- public static EnumerableTuple<T, ValueTuple<T, T, T, T, T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T, T, T, T, T> tuple)
- public static EnumerableTuple<T, Tuple<T, T, T, T, T, T, T>> AsEnumerable<T>(this Tuple<T, T, T, T, T, T, T> tuple)
public struct EnumerableTuple<TItem, TTuple> : IReadOnlyList<TItem>, IEnumerable<TItem>, IEnumerable, IReadOnlyCollection<TItem> where TTuple : ITuple
- public struct Enumerator<TItem, TTuple> : IEnumerator<TItem>, IEnumerator, IDisposable where TTuple : ITuple
- public int Count { get; }
- public TItem this[int index] { get; }
- public int CopyTo(Span<TItem> output)
- public Enumerator<TItem, TTuple> GetEnumerator()
public static class Func
- public static Func<T> Constant<T>(T obj)
- public static Func<T, T> Identity<T>(this Action<T> action)
- public static Func<object, bool> IsTypeOf<T>()
public interface IConsumer<T> : IFunctional<Action<T>>
public interface IFiniteRangeEndpoint<T> : IRangeEndpoint<T>
public interface ICallable
- object Target { get; }
- object DynamicInvoke(object[] args)
public interface ICallable<TDelegate> : ICallable, IConvertible<TDelegate> where TDelegate : Delegate
- TDelegate ToDelegate()
public interface IConvertible<T>
- T Convert()
public interface IOptionMonad<T> : ISupplier<object>, IFunctional<Func<object>>
public interface IOptionMonad<T, TSelf> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>> where TSelf : struct, IOptionMonad<T, TSelf>
public interface IRangeEndpoint<T>
public interface IResettable
public interface IResultMonad<T, TError> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>
public interface IResultMonad<T, TError, TSelf> : IResultMonad<T, TError>, IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>, IOptionMonad<T, TSelf> where TSelf : struct, IResultMonad<T, TError, TSelf>
public interface ISupplier<TResult> : IFunctional<Func<TResult>>
public interface ISupplier<T, TResult> : IFunctional<Func<T, TResult>>
public interface ISupplier<T1, T2, TResult> : IFunctional<Func<T1, T2, TResult>>
public static class ObjectExtensions
- public static T As<T>(this T obj)
- public static void Decompose<T, TResult1, TResult2>(this T obj, Func<T, TResult1> decomposer1, Func<T, TResult2> decomposer2, out TResult1 result1, out TResult2 result2)
- public static void Decompose<T, TResult1, TResult2>(this T obj, ref ValueFunc decomposer1, ref ValueFunc decomposer2, out TResult1 result1, out TResult2 result2)
- public static ValueTuple<TResult1, TResult2> Decompose<T, TResult1, TResult2>(this T obj, Func<T, TResult1> decomposer1, Func<T, TResult2> decomposer2)
- public static ValueTuple<TResult1, TResult2> Decompose<T, TResult1, TResult2>(this T obj, ref ValueFunc decomposer1, ref ValueFunc decomposer2)
- public static UserDataStorage GetUserData<T>(this T obj)
- public static bool IsOneOf<T>(this T value, IEnumerable<T> values)
- public static bool IsOneOf<T>(this T value, T[] values)
public static class OneDimensionalArray
- public static int BitwiseCompare<T>(this T[] first, T[] second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static bool BitwiseEquals<T>(this T[] first, T[] second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T>(this T[] array, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T>(this T[] array, int hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T>(this T[] array, int hash, Func<int, int, int> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static long BitwiseHashCode64<T>(this T[] array, long hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static long BitwiseHashCode64<T>(this T[] array, long hash, Func<long, long, long> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static long BitwiseHashCode64<T>(this T[] array, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static T[] Concat<T>(this T[] left, T[] right, long startIndex)
- public static void ForEach<T>(this T[] array, ref ValueRefAction action)
- public static void ForEach<T>(this T[] array, RefAction<T, long> action)
- public static T[] Insert<T>(this T[] array, T element, long index)
- public static bool IsNullOrEmpty<T>(this T[] array)
- public static T[] RemoveAll<T>(this T[] array, ref ValueFunc match, out long count)
- public static T[] RemoveAll<T>(this T[] array, Predicate<T> match, out long count)
- public static T[] RemoveAll<T>(this T[] array, ref ValueFunc match, ref ValueAction callback)
- public static T[] RemoveAll<T>(this T[] array, Predicate<T> match, Action<T> callback)
- public static T[] RemoveAt<T>(this T[] array, long index)
- public static T[] RemoveFirst<T>(this T[] input, long count)
- public static T[] RemoveLast<T>(this T[] input, long count)
- public static bool SequenceEqual(this object[] first, object[] second, bool parallel = false)
- public static T[] Slice<T>(this T[] input, long startIndex, long length)
- public static ArraySegment<T> Slice<T>(this T[] input, ref Range range)
public static class Optional
- public static Optional<T> Create<T, TMonad>(TMonad value) where TMonad : struct, IOptionMonad<T>
- public static Optional<T> Flatten<T>(this ref Optional optional)
- public static Optional<T> None<T>()
- public static Optional<T> Null<T>()
- public static Optional<T> Some<T>(T value)
public struct Optional<T> : IEquatable<Optional<T>>, IEquatable<T>, IStructuralEquatable, ISerializable
- public static Optional<T> None { get; }
- public static Optional<T> Empty { 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 IsValueDefined(T value)
- public static T op_BitwiseOr(ref Optional optional, T defaultValue)
- public Optional<TResult> Convert<TResult>(ref ValueFunc mapper)
- public Optional<TResult> Convert<TResult>(method mapper)
- public Optional<TResult> Convert<TResult>(ref ValueFunc mapper)
- public Optional<TResult> Convert<TResult>(method mapper)
- 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(ref ValueFunc condition)
- public Optional<T> If(method condition)
- public T OrDefault()
- public T OrInvoke(ref ValueFunc defaultFunc)
- public T OrInvoke(method defaultFunc)
- public T OrThrow(Func<Exception> exceptionFactory)
- public T OrThrow(method exceptionFactory)
- public T OrThrow<TException>(ref ValueFunc exceptionFactory) where TException : Exception
- public T OrThrow<TException>(Func<TException> exceptionFactory) where TException : Exception
- public bool TryGet(out T value, out bool isNull)
public static class Predicate
- public static Predicate<T> Constant<T>(bool value)
- public static ValueFunc<T, bool> AsValueFunc<T>(this Predicate<T> predicate, bool wrap = false)
- public static Predicate<T> False<T>()
- public static Predicate<object> IsTypeOf<T>()
- public static Predicate<T> True<T>()
public static class RandomExtensions
- public static void GetItems<T>(this Random random, Span<T> buffer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void GetItems<T>(this RandomNumberGenerator random, Span<T> buffer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void NextChars(this Random random, ReadOnlySpan<char> allowedChars, Span<char> buffer)
- public static void NextChars(this RandomNumberGenerator random, ReadOnlySpan<char> allowedChars, Span<char> buffer)
- public static string NextString(this Random random, char[] allowedChars, int length)
- public static string NextString(this RandomNumberGenerator random, 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 Result
- public static Result<T> FromException<T>(Exception e)
- public static Result<T> FromValue<T>(T value)
- public static T? OrNull<T, TError>(this ref Result result) where T : struct where TError : struct, Enum
public struct Result<T> : ISerializable
- public T ValueOrDefault { get; }
- public T& modreq(System.Runtime.InteropServices.InAttribute) ValueRef { get; }
- public static Result<T> FromOptional(ref Optional optional)
- public static T op_BitwiseOr(ref Result result, T defaultValue)
- public static Result<T> op_BitwiseOr(ref Result x, ref Result y)
- public static Result<T> op_Explicit(ref Optional optional)
- public Result<TResult> Convert<TResult>(ref ValueFunc converter)
- public Result<TResult> Convert<TResult>(method converter)
- public T OrDefault()
- public T OrInvoke(ref ValueFunc defaultFunc)
- public T OrInvoke(method defaultFunc)
- public T OrInvoke(ref ValueFunc defaultFunc)
- public T OrInvoke(method defaultFunc)
public struct Result<T, TError> : IResultMonad<T, TError, Result<T, TError>>, IResultMonad<T, TError>, IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>, IOptionMonad<T, Result<T, TError>> where TError : struct, Enum
public static class ServiceProviderFactory
public static class Sequence
- public struct LimitedEnumerator<T> : IEnumerator<T>, IEnumerator, IDisposable
- public static IEnumerable<T> Append<T>(this IEnumerable<T> collection, T[] items)
- public static bool ElementAt<T>(this IEnumerable<T> collection, int index, out T element)
- public static ValueTask<Optional<T>> ElementAtAsync<T>(this IAsyncEnumerable<T> collection, int index, CancellationToken token = default)
- public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq)
- public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq, ref ValueFunc filter)
- public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq, Predicate<T> filter)
- public static ValueTask<Optional<T>> FirstOrEmptyAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default)
- public static ValueTask<Optional<T>> FirstOrEmptyAsync<T>(this IAsyncEnumerable<T> seq, ValueFunc<T, bool> filter, CancellationToken token = default)
- public static ValueTask<Optional<T>> FirstOrEmptyAsync<T>(this IAsyncEnumerable<T> seq, Predicate<T> filter, CancellationToken token = default)
- public static T? FirstOrNull<T>(this IEnumerable<T> seq) where T : struct
- public static ValueTask<T?> FirstOrNullAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default) where T : struct
- public static void ForEach<T>(this IEnumerable<T> collection, Action<T> action)
- public static void ForEach<T>(this IEnumerable<T> collection, ref ValueAction action)
- public static ValueTask ForEachAsync<T>(this IAsyncEnumerable<T> collection, ValueAction<T> action, CancellationToken token = default)
- public static ValueTask ForEachAsync<T>(this IAsyncEnumerable<T> collection, Action<T> action, CancellationToken token = default)
- public static ValueTask ForEachAsync<T>(this IAsyncEnumerable<T> collection, ValueFunc<T, CancellationToken, ValueTask> action, CancellationToken token = default)
- public static ValueTask ForEachAsync<T>(this IAsyncEnumerable<T> collection, Func<T, CancellationToken, ValueTask> action, CancellationToken token = default)
- public static ValueTask ForEachAsync<T>(this IEnumerable<T> collection, Func<T, CancellationToken, ValueTask> action, CancellationToken token = default)
- public static ValueTask ForEachAsync<T>(this IEnumerable<T> collection, ValueFunc<T, CancellationToken, ValueTask> action, CancellationToken token = default)
- 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 IEnumerable<T> Prepend<T>(this IEnumerable<T> collection, T[] items)
- public static int SequenceHashCode(this IEnumerable<object> sequence, bool salted = true)
- public static IEnumerable<T> Singleton<T>(T item)
- public static bool Skip<T>(this IEnumerator<T> enumerator, int count)
- public static bool Skip<TEnumerator, T>(this ref TEnumerator enumerator, int count) where TEnumerator : struct, IEnumerator<T>
- public static ValueTask<bool> SkipAsync<T>(this IAsyncEnumerator<T> enumerator, int count)
- public static IAsyncEnumerable<T> SkipNulls<T>(this IAsyncEnumerable<T> collection)
- public static IEnumerable<T> SkipNulls<T>(this IEnumerable<T> collection)
- public static Task<T[]> ToArrayAsync<T>(this IAsyncEnumerable<T> collection, int initialCapacity = 10, MemoryAllocator<T> allocator = null, CancellationToken token = default)
- public static IAsyncEnumerable<T> ToAsyncEnumerable<T>(this IEnumerable<T> enumerable)
- public static IEnumerator<T> ToEnumerator<T>(ReadOnlyMemory<T> memory)
- public static string ToString<T>(this IEnumerable<T> collection, string delimiter, string ifEmpty = "")
public static class Span
- public static ReadOnlySpan<T> Advance<T>(this ref ReadOnlySpan source, int count)
- public static T& modreq(System.Runtime.InteropServices.InAttribute) Advance<T>(this ref ReadOnlySpan source)
- public static Span<T> Advance<T>(this ref Span source, int count)
- public static ref T Advance<T>(this ref Span source)
- public static int BitwiseCompare<T>(this Span<T> first, Span<T> second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static bool BitwiseEquals<T>(this Span<T> first, Span<T> second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static bool CheckMask<T>(this ReadOnlySpan<T> value, ReadOnlySpan<T> mask) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T>(this Span<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T>(this ReadOnlySpan<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T>(this Span<T> span, int hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T>(this Span<T> span, int hash, Func<int, int, int> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T>(this ReadOnlySpan<T> span, int hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T>(this ReadOnlySpan<T> span, int hash, Func<int, int, int> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static long BitwiseHashCode64<T>(this Span<T> span, long hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static long BitwiseHashCode64<T>(this Span<T> span, long hash, Func<long, long, long> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static long BitwiseHashCode64<T>(this ReadOnlySpan<T> span, long hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static long BitwiseHashCode64<T>(this ReadOnlySpan<T> span, long hash, Func<long, long, long> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static long BitwiseHashCode64<T>(this Span<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static long BitwiseHashCode64<T>(this ReadOnlySpan<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static MemoryOwner<char> Concat(ReadOnlySpan<string> values, MemoryAllocator<char> allocator = null)
- public static ReadOnlySpan<TBase> Contravariance<T, TBase>(this ReadOnlySpan<T> span) where T : TBase
- public static 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 = null)
- public static void ForEach<T>(this Span<T> span, ref ValueRefAction action)
- public static void ForEach<T, TArg>(this Span<T> span, method action, TArg arg)
- public static int FromHex(this ReadOnlySpan<char> chars, Span<byte> output)
- public static byte[] FromHex(this ReadOnlySpan<char> chars)
- public static int IndexOf<T>(this ReadOnlySpan<T> span, T value, int startIndex, ref ValueFunc 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 bool IsBitwiseAndNonZero<T>(this ReadOnlySpan<T> value, ReadOnlySpan<T> mask) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- 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 T Read<T>(ref ReadOnlySpan bytes) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void Sort<T>(this Span<T> span, IComparer<T> comparison = null)
- public static void Sort<T>(this Span<T> span, ref ValueFunc comparison)
- public static void Sort<T>(this Span<T> span, Comparison<T> comparison)
- public static int ToHex(this ReadOnlySpan<byte> bytes, Span<char> output, bool lowercased = false)
- public static string ToHex(this ReadOnlySpan<byte> bytes, bool lowercased = false)
- public static Span<T> TrimLength<T>(this Span<T> span, int maxLength, out Span rest)
- public static void Write<T>(ref T value, ref Span output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
public static class StringExtensions
- public static MemoryTemplate<char> AsTemplate(this string template, string placeholder)
- public static MemoryTemplate<char> AsTemplate(this string template, char placeholder)
- public static Char& modreq(System.Runtime.InteropServices.InAttribute) GetRawData(this string str)
- public static string IfNullOrEmpty(this string str, string alt)
- public static bool IsEqualIgnoreCase(this string strA, string strB)
- public static ChunkSequence<char> Split(this string str, int chunkSize)
public struct Supplier<TResult> : ISupplier<TResult>, IFunctional<Func<TResult>>
public struct Supplier<T, TResult> : ISupplier<T, TResult>, IFunctional<Func<T, TResult>>
public struct Supplier<T1, T2, TResult> : ISupplier<T1, T2, TResult>, IFunctional<Func<T1, T2, TResult>>
public struct SupplierClosure<TContext, TResult> : ISupplier<TResult>, IFunctional<Func<TResult>>
public struct SupplierClosure<TContext, T, TResult> : ISupplier<T, TResult>, IFunctional<Func<T, TResult>>
public struct SupplierClosure<TContext, T1, T2, TResult> : ISupplier<T1, T2, TResult>, IFunctional<Func<T1, T2, TResult>>
public static class TupleExtensions
public sealed class UndefinedResultException<TError> : Exception where TError : struct, Enum
public struct UserDataSlot<TValue> : IEquatable<UserDataSlot<TValue>>
- public bool IsAllocated { get; }
- public UserDataSlot()
- public static UserDataSlot<TValue> Allocate()
public struct UserDataStorage
- public bool IsValid { get; }
- public IReadOnlyDictionary<string, object> Capture()
- public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot, method 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, method valueFactory)
- public TValue GetOrSet<TValue, TFactory>(UserDataSlot<TValue> slot, TFactory valueFactory) where TFactory : struct, ISupplier<TValue>
- public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot, ref ValueFunc valueFactory)
- public TValue GetOrSet<T, TValue>(UserDataSlot<TValue> slot, T arg, ref ValueFunc valueFactory)
- public TValue GetOrSet<T1, T2, TValue>(UserDataSlot<TValue> slot, T1 arg1, T2 arg2, ref ValueFunc valueFactory)
public struct ValueSupplier<T> : ISupplier<T>, IFunctional<Func<T>>
public struct ValueAction : IValueDelegate<Action>, ICallable<Action>, ICallable, IConvertible<Action>, ISupplier<Action>, IEquatable<ValueAction>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueAction(MethodInfo method)
- public ValueAction(Action action, bool wrap = false)
- public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueAction first, ref ValueAction second)
- public static Action op_Explicit(ref ValueAction pointer)
- public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
- public bool Equals(ValueAction other)
- public void Invoke()
- public Action ToDelegate()
public struct ValueAction<T> : IValueDelegate<Action<T>>, ICallable<Action<T>>, ICallable, IConvertible<Action<T>>, ISupplier<Action<T>>, IEquatable<ValueAction<T>>, IConsumer<T>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueAction(MethodInfo method)
- public ValueAction(Action<T> action, bool wrap = false)
- public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueAction first, ref ValueAction second)
- public static Action<T> op_Explicit(ref ValueAction pointer)
- public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
- public bool Equals(ValueAction<T> other)
- public void Invoke(T arg)
- public Action<T> ToDelegate()
public struct ValueAction<T1, T2> : IValueDelegate<Action<T1, T2>>, ICallable<Action<T1, T2>>, ICallable, IConvertible<Action<T1, T2>>, ISupplier<Action<T1, T2>>, IEquatable<ValueAction<T1, T2>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueAction(MethodInfo method)
- public ValueAction(Action<T1, T2> action, bool wrap = false)
- public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueAction first, ref ValueAction second)
- public static Action<T1, T2> op_Explicit(ref ValueAction pointer)
- public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
- public bool Equals(ValueAction<T1, T2> other)
- public void Invoke(T1 arg1, T2 arg2)
- public Action<T1, T2> ToDelegate()
public struct ValueAction<T1, T2, T3> : IValueDelegate<Action<T1, T2, T3>>, ICallable<Action<T1, T2, T3>>, ICallable, IConvertible<Action<T1, T2, T3>>, ISupplier<Action<T1, T2, T3>>, IEquatable<ValueAction<T1, T2, T3>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueAction(MethodInfo method)
- public ValueAction(Action<T1, T2, T3> action, bool wrap = false)
- public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueAction first, ref ValueAction second)
- public static Action<T1, T2, T3> op_Explicit(ref ValueAction pointer)
- public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
- public bool Equals(ValueAction<T1, T2, T3> other)
- public void Invoke(T1 arg1, T2 arg2, T3 arg3)
- public Action<T1, T2, T3> ToDelegate()
public struct ValueAction<T1, T2, T3, T4> : IValueDelegate<Action<T1, T2, T3, T4>>, ICallable<Action<T1, T2, T3, T4>>, ICallable, IConvertible<Action<T1, T2, T3, T4>>, ISupplier<Action<T1, T2, T3, T4>>, IEquatable<ValueAction<T1, T2, T3, T4>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueAction(MethodInfo method)
- public ValueAction(Action<T1, T2, T3, T4> action, bool wrap = false)
- public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueAction first, ref ValueAction second)
- public static Action<T1, T2, T3, T4> op_Explicit(ref ValueAction pointer)
- public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
- public bool Equals(ValueAction<T1, T2, T3, T4> other)
- public void Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
- public Action<T1, T2, T3, T4> ToDelegate()
public struct ValueAction<T1, T2, T3, T4, T5> : IValueDelegate<Action<T1, T2, T3, T4, T5>>, ICallable<Action<T1, T2, T3, T4, T5>>, ICallable, IConvertible<Action<T1, T2, T3, T4, T5>>, ISupplier<Action<T1, T2, T3, T4, T5>>, IEquatable<ValueAction<T1, T2, T3, T4, T5>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueAction(MethodInfo method)
- public ValueAction(Action<T1, T2, T3, T4, T5> action, bool wrap = false)
- public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueAction first, ref ValueAction second)
- public static Action<T1, T2, T3, T4, T5> op_Explicit(ref ValueAction pointer)
- public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
- public bool Equals(ValueAction<T1, T2, T3, T4, T5> other)
- public void Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
- public Action<T1, T2, T3, T4, T5> ToDelegate()
public struct ValueFunc<TResult> : IValueDelegate<Func<TResult>>, ICallable<Func<TResult>>, ICallable, IConvertible<Func<TResult>>, ISupplier<Func<TResult>>, IEquatable<ValueFunc<TResult>>, ISupplier<TResult>
- public static ValueFunc<TResult> Activator { get; }
- public static ValueFunc<TResult> DefaultValueProvider { get; }
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueFunc(MethodInfo method)
- public ValueFunc(Func<TResult> func, bool wrap = false)
- public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
- public static Func<TResult> op_Explicit(ref ValueFunc pointer)
- public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
- public bool Equals(ValueFunc<TResult> other)
- public TResult Invoke()
- public Func<TResult> ToDelegate()
public struct ValueFunc<T, TResult> : IValueDelegate<Func<T, TResult>>, ICallable<Func<T, TResult>>, ICallable, IConvertible<Func<T, TResult>>, ISupplier<Func<T, TResult>>, IValueDelegate<Converter<T, TResult>>, ICallable<Converter<T, TResult>>, IConvertible<Converter<T, TResult>>, ISupplier<Converter<T, TResult>>, IEquatable<ValueFunc<T, TResult>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueFunc(MethodInfo method)
- public ValueFunc(Func<T, TResult> func, bool wrap = false)
- public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
- public static Func<T, TResult> op_Explicit(ref ValueFunc func)
- public static Converter<T, TResult> op_Explicit(ref ValueFunc func)
- public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
- public bool Equals(ValueFunc<T, TResult> other)
- public TResult Invoke(T arg)
- public Func<T, TResult> ToDelegate()
public struct ValueFunc<T1, T2, TResult> : IValueDelegate<Func<T1, T2, TResult>>, ICallable<Func<T1, T2, TResult>>, ICallable, IConvertible<Func<T1, T2, TResult>>, ISupplier<Func<T1, T2, TResult>>, IEquatable<ValueFunc<T1, T2, TResult>>, ISupplier<T1, T2, TResult>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueFunc(MethodInfo method)
- public ValueFunc(Func<T1, T2, TResult> func, bool wrap = false)
- public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
- public static Func<T1, T2, TResult> op_Explicit(ref ValueFunc pointer)
- public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
- public bool Equals(ValueFunc<T1, T2, TResult> other)
- public TResult Invoke(T1 arg1, T2 arg2)
- public Func<T1, T2, TResult> ToDelegate()
public struct ValueFunc<T1, T2, T3, TResult> : IValueDelegate<Func<T1, T2, T3, TResult>>, ICallable<Func<T1, T2, T3, TResult>>, ICallable, IConvertible<Func<T1, T2, T3, TResult>>, ISupplier<Func<T1, T2, T3, TResult>>, IEquatable<ValueFunc<T1, T2, T3, TResult>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueFunc(MethodInfo method)
- public ValueFunc(Func<T1, T2, T3, TResult> func, bool wrap = false)
- public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
- public static Func<T1, T2, T3, TResult> op_Explicit(ref ValueFunc pointer)
- public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
- public bool Equals(ValueFunc<T1, T2, T3, TResult> other)
- public TResult Invoke(T1 arg1, T2 arg2, T3 arg3)
- public Func<T1, T2, T3, TResult> ToDelegate()
public struct ValueFunc<T1, T2, T3, T4, TResult> : IValueDelegate<Func<T1, T2, T3, T4, TResult>>, ICallable<Func<T1, T2, T3, T4, TResult>>, ICallable, IConvertible<Func<T1, T2, T3, T4, TResult>>, ISupplier<Func<T1, T2, T3, T4, TResult>>, IEquatable<ValueFunc<T1, T2, T3, T4, TResult>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueFunc(MethodInfo method)
- public ValueFunc(Func<T1, T2, T3, T4, TResult> func, bool wrap = false)
- public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
- public static Func<T1, T2, T3, T4, TResult> op_Explicit(ref ValueFunc pointer)
- public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
- public bool Equals(ValueFunc<T1, T2, T3, T4, TResult> other)
- public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
- public Func<T1, T2, T3, T4, TResult> ToDelegate()
public struct ValueFunc<T1, T2, T3, T4, T5, TResult> : IValueDelegate<Func<T1, T2, T3, T4, T5, TResult>>, ICallable<Func<T1, T2, T3, T4, T5, TResult>>, ICallable, IConvertible<Func<T1, T2, T3, T4, T5, TResult>>, ISupplier<Func<T1, T2, T3, T4, T5, TResult>>, IEquatable<ValueFunc<T1, T2, T3, T4, T5, TResult>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueFunc(MethodInfo method)
- public ValueFunc(Func<T1, T2, T3, T4, T5, TResult> func, bool wrap = false)
- public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
- public static Func<T1, T2, T3, T4, T5, TResult> op_Explicit(ref ValueFunc pointer)
- public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
- public bool Equals(ValueFunc<T1, T2, T3, T4, T5, TResult> other)
- public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
- public Func<T1, T2, T3, T4, T5, TResult> ToDelegate()
public struct ValueRefAction<T, TArgs> : IValueDelegate<RefAction<T, TArgs>>, ICallable<RefAction<T, TArgs>>, ICallable, IConvertible<RefAction<T, TArgs>>, ISupplier<RefAction<T, TArgs>>, IEquatable<ValueRefAction<T, TArgs>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueRefAction(MethodInfo method)
- public ValueRefAction(RefAction<T, TArgs> action, bool wrap = false)
- public ValueRefAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueRefAction first, ref ValueRefAction second)
- public static RefAction<T, TArgs> op_Explicit(ref ValueRefAction pointer)
- public static bool op_Inequality(ref ValueRefAction first, ref ValueRefAction second)
- public bool Equals(ValueRefAction<T, TArgs> other)
- public void Invoke(ref T reference, TArgs args)
- public RefAction<T, TArgs> ToDelegate()
public struct ValueRefFunc<T, TArgs, TResult> : IValueDelegate<RefFunc<T, TArgs, TResult>>, ICallable<RefFunc<T, TArgs, TResult>>, ICallable, IConvertible<RefFunc<T, TArgs, TResult>>, ISupplier<RefFunc<T, TArgs, TResult>>, IEquatable<ValueRefFunc<T, TArgs, TResult>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueRefFunc(MethodInfo method)
- public ValueRefFunc(RefFunc<T, TArgs, TResult> func, bool wrap = false)
- public ValueRefFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueRefFunc first, ref ValueRefFunc second)
- public static RefFunc<T, TArgs, TResult> op_Explicit(ref ValueRefFunc pointer)
- public static bool op_Inequality(ref ValueRefFunc first, ref ValueRefFunc second)
- public bool Equals(ValueRefFunc<T, TArgs, TResult> other)
- public TResult Invoke(ref T reference, TArgs args)
- public RefFunc<T, TArgs, TResult> ToDelegate()
public static class ValueTypeExtensions
- public static IntPtr Add(this IntPtr x, IntPtr y)
- public static UIntPtr Add(this UIntPtr x, UIntPtr y)
- public static IntPtr AddChecked(this IntPtr x, IntPtr y)
- public static UIntPtr AddChecked(this UIntPtr x, UIntPtr y)
- public static UIntPtr And(this UIntPtr x, UIntPtr y)
- public static IntPtr And(this IntPtr x, IntPtr y)
- public static IntPtr Decrement(this IntPtr value)
- public static UIntPtr Decrement(this UIntPtr value)
- public static IntPtr Divide(this IntPtr x, IntPtr y)
- public static UIntPtr Divide(this UIntPtr x, UIntPtr y)
- public static float EnsureFinite(this float value)
- public static double EnsureFinite(this double value)
- public static bool GreaterThan(this IntPtr value, IntPtr comparand)
- public static bool GreaterThan(this UIntPtr value, UIntPtr comparand)
- public static bool GreaterThanOrEqual(this IntPtr value, IntPtr comparand)
- public static bool GreaterThanOrEqual(this UIntPtr value, UIntPtr comparand)
- public static IntPtr Increment(this IntPtr value)
- public static UIntPtr Increment(this UIntPtr value)
- public static bool IsOneOf<T>(this T value, IEnumerable<T> values) where T : struct, IEquatable<T>
- public static bool IsOneOf<T>(this T value, T[] values) where T : struct, IEquatable<T>
- public static bool LessThan(this IntPtr value, IntPtr comparand)
- public static bool LessThan(this UIntPtr value, UIntPtr comparand)
- public static bool LessThanOrEqual(this IntPtr value, IntPtr comparand)
- public static bool LessThanOrEqual(this UIntPtr value, UIntPtr comparand)
- public static IntPtr Multiply(this IntPtr x, IntPtr y)
- public static UIntPtr Multiply(this UIntPtr x, UIntPtr y)
- public static IntPtr MultiplyChecked(this IntPtr x, IntPtr y)
- public static UIntPtr MultiplyChecked(this UIntPtr x, UIntPtr y)
- public static IntPtr Negate(this IntPtr value)
- public static IntPtr OnesComplement(this IntPtr value)
- public static UIntPtr OnesComplement(this UIntPtr value)
- public static IntPtr Or(this IntPtr x, IntPtr y)
- public static UIntPtr Or(this UIntPtr x, UIntPtr y)
- public static IntPtr Remainder(this IntPtr x, IntPtr y)
- public static UIntPtr Remainder(this UIntPtr x, UIntPtr y)
- public static IntPtr Subtract(this IntPtr x, IntPtr y)
- public static UIntPtr Subtract(this UIntPtr x, UIntPtr y)
- public static IntPtr SubtractChecked(this IntPtr x, IntPtr y)
- public static UIntPtr SubtractChecked(this UIntPtr x, UIntPtr y)
- public static bool ToBoolean(this int value)
- public static byte ToByte(this bool value)
- public static int ToInt32(this bool value)
- public static IntPtr ToIntPtr(this UIntPtr value)
- public static UIntPtr ToUIntPtr(this IntPtr value)
- public static int Truncate(this long value)
- public static bool TryGetValue<T>(this T? nullable, out T value) where T : struct
- public static IntPtr Xor(this IntPtr x, IntPtr y)
- public static UIntPtr Xor(this UIntPtr x, UIntPtr y)

DotNext.Buffers

public struct BufferConsumer<T> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>, IEquatable<BufferConsumer<T>>
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 struct BufferWriterInterpolatedStringHandler
public struct BufferWriterSlim<T>
public struct BufferWriterSlimInterpolatedStringHandler
public static class ByteBuffer
public static class CharBuffer
public struct DelegatingReadOnlySpanConsumer<T, TArg> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>
public interface IGrowableBuffer<T> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>, IDisposable, IResettable
public interface IReadOnlySpanConsumer<T> : ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>
public static class Memory
public struct ArrayRental<T> : IMemoryOwner<T>, IDisposable, IConvertible<Memory<T>>, IConvertible<ArraySegment<T>>, IConvertible<MemoryOwner<T>>
- public bool IsEmpty { get; }
- public ref T this[long index] { get; }
- public int Length { get; }
- public Memory<T> Memory { get; }
- public MemoryOwner<T> Owner { get; }
- public ArraySegment<T> Segment { get; }
- public Span<T> Span { get; }
- public ArrayRental(ArrayPool<T> pool, int minimumLength, bool clearArray)
- public ArrayRental(ArrayPool<T> pool, int minimumLength)
- public ArrayRental(int minimumLength, bool clearArray)
- public ArrayRental(int minimumLength)
- public ArrayRental(T[] array, int length)
- public ArrayRental(T[] array)
- public static MemoryOwner<T> op_Implicit(ref ArrayRental array)
- public void Clear()
- public void Dispose()
- public ref T GetPinnableReference()
public static class ChunkSequence
- public static ReadOnlySequence<T> Concat<T>(this Memory<T> first, Memory<T> second)
- public static ValueTask CopyToAsync(this ChunkSequence<byte> sequence, Stream output, CancellationToken token = default)
- public static ValueTask CopyToAsync(this ChunkSequence<char> sequence, TextWriter output, CancellationToken token = default)
- public static ReadOnlySequence<T> ToReadOnlySequence<T>(this IEnumerable<Memory<T>> chunks)
public struct ChunkSequence<T> : IEnumerable<ReadOnlyMemory<T>>, IEnumerable
- public struct Enumerator<T> : IEnumerator<ReadOnlyMemory<T>>, IEnumerator, IDisposable
- public ChunkSequence(ReadOnlyMemory<T> memory, int chunkSize)
- public static ReadOnlySequence<T> op_Explicit(ChunkSequence<T> sequence)
- public Enumerator<T> GetEnumerator()
- public ReadOnlySequence<T> ToReadOnlySequence()
public static class MemoryAllocator
- public static MemoryAllocator<T> CreateArrayAllocator<T>()
- public static MemoryOwner<T> Invoke<T>(this MemoryAllocator<T> allocator, int length, bool exactSize)
- public static MemoryAllocator<T> ToAllocator<T>(this ArrayPool<T> pool)
- public static MemoryAllocator<T> ToAllocator<T>(this MemoryPool<T> pool)
- public static MemoryAllocator<T> ToAllocator<T>(this Func<int, IMemoryOwner<T>> provider)
public struct MemoryOwner<T> : IMemoryOwner<T>, IDisposable, IConvertible<Memory<T>>
- public Span<T> Span { get; }
- 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 sealed class PoolingBufferWriter<T> : BufferWriter<T>, IMemoryOwner<T>, IDisposable
public struct PoolingInterpolatedStringHandler : IGrowableBuffer<char>, IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IDisposable, IResettable
public static class ReadOnlySequencePartitioner
public struct ReadOnlySpanConsumer<T, TArg> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>
public struct SpanOwner<T>
public struct SpanReader<T>
public struct SpanWriter<T>
public enum SparseBufferGrowth
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 MemoryRental<T>
- public static int StackallocThreshold { get; }
- public bool IsEmpty { get; }
- public ref T this[int index] { get; }
- public int Length { get; }
- public Span<T> Span { get; }
- public MemoryRental(Span<T> span)
- public MemoryRental(Span<T> span, int length)
- public MemoryRental(MemoryPool<T> pool, int minBufferSize)
- public MemoryRental(MemoryPool<T> pool)
- public MemoryRental(int minBufferSize)
- public static MemoryRental<T> op_Implicit(Span<T> span)
- public void Dispose()
- public ref T GetPinnableReference()
public static class MemoryTemplate
- public static void Render(this ref MemoryTemplate template, StringBuilder output, string[] replacement)
- public static string Render(this ref MemoryTemplate template, string[] replacement)
- public static void Render(this ref MemoryTemplate template, TextWriter output, string[] replacement)
public struct MemoryTemplate<T> where T : IEquatable<T>
- public ReadOnlyMemory<T> Value { get; }
- public MemoryTemplate(ReadOnlyMemory<T> template, ReadOnlySpan<T> placeholder)
- public void Render<TWriter>(TWriter output, Action<int, TWriter> rewriter) where TWriter : IBufferWriter<T>
- public void Render<TArg>(TArg arg, Action<int, TArg> rewriter, ReadOnlySpanAction<T, TArg> output)
public abstract class MemoryWriter<T> : Disposable, IBufferWriter<T>, IConvertible<ReadOnlyMemory<T>>, IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>
- public abstract int Capacity { get; }
- public int FreeCapacity { get; }
- public T& modreq(System.Runtime.InteropServices.InAttribute) this[int index] { get; }
- public int WrittenCount { get; }
- public abstract ReadOnlyMemory<T> WrittenMemory { get; }
- public void Add(T item)
- public void AddAll(ICollection<T> items)
- public void Advance(int count)
- public virtual void Clear()
- public abstract void Clear(bool reuseBuffer)
- public IEnumerator<T> GetEnumerator()
- public abstract Memory<T> GetMemory(int sizeHint = 0)
- public virtual Span<T> GetSpan(int sizeHint = 0)
public static class PooledArrayBufferWriter
- public static Stream GetWrittenBytesAsStream(this PooledArrayBufferWriter<byte> writer)
public sealed class PooledArrayBufferWriter<T> : MemoryWriter<T>, IConvertible<ArraySegment<T>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
- public ref T this[int index] { get; }
- public ArraySegment<T> WrittenArray { get; }
- public PooledArrayBufferWriter(ArrayPool<T> pool, int initialCapacity)
- public PooledArrayBufferWriter(ArrayPool<T> pool)
- public PooledArrayBufferWriter()
- public PooledArrayBufferWriter(int initialCapacity)
- public ArraySegment<T> GetArray(int sizeHint = 0)
public sealed class PooledBufferWriter<T> : MemoryWriter<T>
- public PooledBufferWriter(MemoryAllocator<T> allocator, int initialCapacity)
- public PooledBufferWriter(MemoryAllocator<T> allocator)

DotNext.Buffers.Binary

public static class BinaryTransformations
public struct Blittable<T> : IBinaryFormattable<Blittable<T>> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
public interface IBinaryFormattable<TSelf> where TSelf : IBinaryFormattable<TSelf>

DotNext.Buffers.Text

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

DotNext.Collections.Generic

public static class AsyncEnumerable
public static class Collection
- public struct ConsumingEnumerable<T> : IEnumerable<T>, IEnumerable
- public static IEnumerable<T> Append<T>(this IEnumerable<T> collection, T[] items)
- public static ReadOnlyCollectionView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyCollection<TInput> collection, ref ValueFunc 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 Optional<T> FirstOrNone<T>(this IEnumerable<T> collection)
- 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 Optional<T> LastOrNone<T>(this IEnumerable<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 IAsyncEnumerator<T> ToAsyncEnumerator<TEnumerator, T>(this TEnumerator enumerator, CancellationToken token) where TEnumerator : struct, IEnumerator<TEnumerator, T>
- public static IEnumerator<T> ToClassicEnumerator<TEnumerator, T>(this TEnumerator enumerator) where TEnumerator : struct, IEnumerator<TEnumerator, T>
- public static string ToString<T>(this IEnumerable<T> collection, string delimiter, string ifEmpty = "")
public static class Dictionary
- public static ReadOnlyDictionaryView<TKey, TValue, TResult> ConvertValues<TKey, TValue, TResult>(this IReadOnlyDictionary<TKey, TValue> dictionary, ref ValueFunc mapper)
- public static void ForEach<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, ref ValueAction action)
- public static TValue GetOrAdd<TKey, TValue, 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, ref ValueFunc 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, ref ValueFunc defaultValue)
public static class Enumerator
public interface IEnumerator<TSelf, T> where TSelf : struct, IEnumerator<TSelf, T>
public static class List
- public static ReadOnlyListView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyList<TInput> list, ref ValueFunc converter)
- 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, ref ValueFunc comparer)
- public static int InsertOrdered<T>(this IList<T> list, T item, method comparer)
- public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, ref ValueFunc mapper)
- public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, method mapper)
- public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, ref ValueFunc mapper)
- public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, method mapper)
public struct ListSegment<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyList<T>, IReadOnlyCollection<T>
- public bool TryGetSpan(out Span span)
public struct ReadOnlyCollectionView<TInput, TOutput> : IReadOnlyCollection<TOutput>, IEnumerable<TOutput>, IEnumerable, IEquatable<ReadOnlyCollectionView<TInput, TOutput>>
- public ReadOnlyCollectionView(IReadOnlyCollection<TInput> collection, 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 ReadOnlyCollectionView(IReadOnlyCollection<TInput> collection, ref ValueFunc mapper)
- public static bool op_Equality(ReadOnlyCollectionView<TInput, TOutput> first, ReadOnlyCollectionView<TInput, TOutput> second)
- public static bool op_Inequality(ReadOnlyCollectionView<TInput, TOutput> first, ReadOnlyCollectionView<TInput, TOutput> second)
public struct ReadOnlyDictionaryView<TKey, TInput, TOutput> : IReadOnlyDictionary<TKey, TOutput>, IEnumerable<KeyValuePair<TKey, TOutput>>, IEnumerable, IReadOnlyCollection<KeyValuePair<TKey, TOutput>>, IEquatable<ReadOnlyDictionaryView<TKey, TInput, TOutput>>
- public ReadOnlyDictionaryView(IReadOnlyDictionary<TKey, TInput> dictionary, 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 ReadOnlyDictionaryView(IReadOnlyDictionary<TKey, TInput> dictionary, ref ValueFunc mapper)
- public static bool op_Equality(ReadOnlyDictionaryView<TKey, TInput, TOutput> first, ReadOnlyDictionaryView<TKey, TInput, TOutput> second)
- public static bool op_Inequality(ReadOnlyDictionaryView<TKey, TInput, TOutput> first, ReadOnlyDictionaryView<TKey, TInput, TOutput> second)
public struct ReadOnlyListView<TInput, TOutput> : IReadOnlyList<TOutput>, IEnumerable<TOutput>, IEnumerable, IReadOnlyCollection<TOutput>, IEquatable<ReadOnlyListView<TInput, TOutput>>
- 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 ReadOnlyListView(IReadOnlyList<TInput> list, ref ValueFunc mapper)
- public static bool op_Equality(ReadOnlyListView<TInput, TOutput> first, ReadOnlyListView<TInput, TOutput> second)
- public static bool op_Inequality(ReadOnlyListView<TInput, TOutput> first, ReadOnlyListView<TInput, TOutput> second)
public static class Set
public static class Stack
- public static Stack<T> Clone<T>(this Stack<T> original)
- public static bool TryPeek<T>(this Stack<T> stack, out T obj)
- public static bool TryPop<T>(this Stack<T> stack, out T obj)

DotNext.Generic

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

DotNext.IO

public interface IFlushable
- void DiscoverFlushMethods<T>(T obj, ref Action flush, ref Func flushAsync)
- Func<T, CancellationToken, Task> TryReflectAsyncFlushMethod<T>(T obj)
- Action<T> TryReflectFlushMethod<T>(T obj)
public struct StreamConsumer : IReadOnlySpanConsumer<byte>, ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<byte>, CancellationToken, ValueTask>>, IEquatable<StreamConsumer>, IFlushable
public static class StreamSource
- public static Stream AsAsynchronousStream<TOutput>(TOutput output) where TOutput : ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>, IFlushable
- public static Stream AsSharedStream(this ReadOnlySequence<byte> sequence, bool compatWithAsync = true)
- public static Stream AsStream(this SparseBufferWriter<byte> writer, bool readable)
- 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 static Stream GetWrittenBytesAsStream(this PooledArrayBufferWriter<byte> writer)
public struct TextConsumer : IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IFlushable, IEquatable<TextConsumer>

DotNext.IO.Hashing

public class FNV1a<THash, TParameters> : NonCryptographicHashAlgorithm, IResettable where THash : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), IBinaryNumber<THash> where TParameters : IFNV1aParameters<THash>
public sealed class FNV1a128 : FNV1a<Int128, FNV1aParameters>
public sealed class FNV1a32 : FNV1a<int, FNV1aParameters>
public sealed class FNV1a64 : FNV1a<long, FNV1aParameters>
public struct FNV1aParameters : IFNV1aParameters<int>, IFNV1aParameters<long>, IFNV1aParameters<Int128>
public interface IFNV1aParameters<THash> where THash : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)

DotNext.Net.Http

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

DotNext.Numerics

public static class Number

DotNext.Patterns

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

DotNext.Reflection

public static class DisposableType
- public static MethodInfo GetDisposeAsyncMethod(this Type type)
public static class EnumType
public static class MethodExtensions
- public static Result<object> TryInvoke(this MethodBase method, object obj, object[] args)
public static class PropertyExtensions
public static class TaskType
- public static Func<Task, bool> IsCompletedSuccessfullyGetter { get; }
- public static Func<bool> GetIsCompletedGetter(this Task task)
- public static Func<Task<T>, T> GetResultGetter<T>()
- public static Type MakeTaskType(this Type taskResult, bool valueTask = false)
- public static Type MakeTaskType(this Type taskResult)
public static class TypeExtensions
- public static object GetDefaultValue(this Type type)

DotNext.Resources

public struct ResourceEntry
public static class ResourceManagerExtensions

DotNext.Runtime

public abstract class BoxedValue<T> where T : struct
public struct GCLatencyModeScope : IDisposable
public abstract class GCNotification
public static class Intrinsics
- public static int AlignOf<T>()
- public static bool AreCompatible<T1, T2>()
- public static bool AreSame<T>(ref T first, ref T second)
- public static void Bitcast<T, TResult>(ref T input, out TResult output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where TResult : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int Compare(Void* first, Void* second, UIntPtr length)
- public static void ClearBits(Void* address, long length)
- public static int Compare(Void* first, Void* second, long length)
- public static void Copy<T>(ref T source, out T destination, UIntPtr count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void Copy<T>(ref T source, ref T destination, long count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static bool Equals(Void* first, Void* second, UIntPtr length)
- public static UIntPtr GetLength(this Array array)
- public static bool HasFinalizer(object obj)
- public static T DefaultOf<T>()
- public static bool Equals(Void* first, Void* second, long length)
- public static Exception Error(object obj)
- public static int GetHashCode32(Void* source, long length, int hash, Func<int, int, int> hashFunction, bool salted = true)
- public static int GetHashCode32(Void* source, long length, int hash, ref ValueFunc hashFunction, bool salted = true)
- public static int GetHashCode32(Void* source, long length, bool salted = true)
- public static long GetHashCode64(Void* source, long length, long hash, Func<long, long, long> hashFunction, bool salted = true)
- public static long GetHashCode64(Void* source, long length, long hash, ref ValueFunc hashFunction, bool salted = true)
- public static long GetHashCode64(Void* source, long length, bool salted = true)
- public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReadonlyRef<T>(this T[] array, long index)
- public static TBase& modreq(System.Runtime.InteropServices.InAttribute) GetReadonlyRef<T, TBase>(this T[] array, long index) where T : TBase
- public static bool HasFlag<T>(T value, T flag) where T : struct, Enum
- public static bool IsNull<T>(ref T value)
- public static int PointerHashCode(Void* pointer)
- public static void Reverse<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static T ShallowCopy<T>(T obj)
- public static void Throw(object obj)
- public static void ThrowIfNull<T>(ref T value)
public struct ReadOnlyValueReference<T> : IEquatable<ReadOnlyValueReference<T>>, IEqualityOperators<ReadOnlyValueReference<T>, ReadOnlyValueReference<T>, bool>, ISupplier<T>, IFunctional<Func<T>>
public sealed class SoftReference<T> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>
public class SoftReferenceOptions
public enum SoftReferenceState
public struct ValueReference<T> : IEquatable<ValueReference<T>>, IEqualityOperators<ValueReference<T>, ValueReference<T>, bool>, ISupplier<T>, IFunctional<Func<T>>, IConsumer<T>, IFunctional<Action<T>>

DotNext.Runtime.Caching

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

DotNext.Runtime.CompilerServices

public interface IFunctional<TDelegate> where TDelegate : Delegate
public struct Scope : IDisposable, IAsyncDisposable
public struct SpawningAsyncTaskMethodBuilder
public struct SpawningAsyncTaskMethodBuilder<TResult>
public struct SuspendedExceptionTaskAwaitable
public struct SuspendedExceptionTaskAwaitable<TArg>
public abstract class AsyncDelegateFuture : Future<Task>, IAwaiter, IFuture, INotifyCompletion
- public IAwaiter GetAwaiter()
public struct Box<T> : IEquatable<Box<T>> where T : struct
- public bool IsEmpty { get; }
- public ref T Value { get; }
- public Box(object boxed)
- public Box(T value)
- public static bool op_Equality(Box<T> x, Box<T> y)
- public static T op_Explicit(Box<T> box)
- public static bool op_Inequality(Box<T> x, Box<T> y)
- public bool Equals(Box<T> other)
public sealed class CallerMustBeSynchronizedAttribute : Attribute
- public CallerMustBeSynchronizedAttribute()
public struct ManagedMethodPointer : IEquatable<ManagedMethodPointer>
- public static bool op_Equality(ManagedMethodPointer x, ManagedMethodPointer y)
- public static bool op_Inequality(ManagedMethodPointer x, ManagedMethodPointer y)
- public bool Equals(ManagedMethodPointer other)
public sealed class RuntimeFeaturesAttribute : Attribute
- public bool Augmentation
- public bool DynamicCodeCompilation
- public bool PrivateReflection
- public bool RuntimeGenericInstantiation
- public RuntimeFeaturesAttribute()

DotNext.Runtime.ExceptionServices

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

DotNext.Runtime.InteropServices

public static class SafeBufferExtensions

DotNext.Security.Cryptography

public struct HashBuilder : ICryptoTransform, IDisposable
- public int HashSize { get; }
- public bool IsEmpty { get; }
- public HashBuilder(HashAlgorithm algorithm, bool leaveOpen = true)
- public HashBuilder(string hashName)
- public void Add(ReadOnlySpan<byte> bytes)
- public void Add(ReadOnlySequence<byte> bytes)
- public void Add<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public int Build(Span<byte> hash)
- public void Dispose()
- public void Reset()

DotNext.Text

public static class InterpolatedString
public struct StringBuilderConsumer : IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IEquatable<StringBuilderConsumer>

DotNext.Text.Json

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

DotNext.Threading

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

DotNext.Threading.Tasks

public static class CompletedTask<T, TConstant> where TConstant : Constant<T>
- public static readonly Task<T> Task
public static class Continuation
- public static Task<T> ContinueWithTimeout<T>(this Task<T> task, TimeSpan timeout, CancellationToken token = default)
- public static Task<T> OnCanceled<T, TConstant>(this Task<T> task, TaskScheduler scheduler = null) where TConstant : Constant<T>
- public static Task<Task> OnCompleted(this Task task)
- public static Task<Task<TResult>> OnCompleted<TResult>(this Task<TResult> task)
- public static Task<T> OnFaulted<T, TConstant>(this Task<T> task, TaskScheduler scheduler = null) where TConstant : Constant<T>
- public static Task<T> OnFaultedOrCanceled<T, TConstant>(this Task<T> task, TaskScheduler scheduler = null) where TConstant : Constant<T>
public static class Conversion
- public static SuspendedExceptionTaskAwaitable SuspendException(this Task task, Predicate<Exception> filter = null)
- public static SuspendedExceptionTaskAwaitable SuspendException(this ValueTask task, Predicate<Exception> filter = null)
- public static SuspendedExceptionTaskAwaitable<TArg> SuspendException<TArg>(this Task task, TArg arg, Func<Exception, TArg, bool> filter)
- public static SuspendedExceptionTaskAwaitable<TArg> SuspendException<TArg>(this ValueTask task, TArg arg, Func<Exception, TArg, bool> filter)
public struct DynamicTaskAwaitable
- public DynamicTaskAwaitable ConfigureAwait(ConfigureAwaitOptions options)
public abstract class Future : IFuture, INotifyCompletion
- public interface IAwaiter : IFuture, INotifyCompletion
- public interface IAwaiter<TResult> : IFuture, INotifyCompletion
- protected sealed class IncompletedFutureException : InvalidOperationException
- public abstract bool IsCompleted { get; }
- protected Future(bool runContinuationsAsynchronously = true)
- protected void Complete()
- public void OnCompleted(Action callback)
public abstract class Future<T> : Future, IConvertible<T> where T : Task
- protected Future(bool runContinuationsAsynchronously = true)
- public abstract T AsTask()
public interface IFuture : INotifyCompletion
- bool IsCompleted { get; }
public static class Synchronization
- public static Result<TResult>? TryGetResult<TResult>(this Task<TResult> task)
- public static Task<ValueTuple<Result<T1>, Result<T2>>> WhenAll<T1, T2>(Task<T1> task1, Task<T2> task2)
- public static Task<ValueTuple<Result<T1>, Result<T2>, Result<T3>>> WhenAll<T1, T2, T3>(Task<T1> task1, Task<T2> task2, Task<T3> task3)
- public static Task<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>>> WhenAll<T1, T2, T3, T4>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4)
- public static Task<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>, Result<T5>>> WhenAll<T1, T2, T3, T4, T5>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4, Task<T5> task5)
- public static ValueTask WhenAll(ValueTask task1, ValueTask task2)
- public static ValueTask<ValueTuple<Result<T1>, Result<T2>>> WhenAll<T1, T2>(ValueTask<T1> task1, ValueTask<T2> task2)
- public static ValueTask WhenAll(ValueTask task1, ValueTask task2, ValueTask task3)
- public static ValueTask<ValueTuple<Result<T1>, Result<T2>, Result<T3>>> WhenAll<T1, T2, T3>(ValueTask<T1> task1, ValueTask<T2> task2, ValueTask<T3> task3)
- public static ValueTask WhenAll(ValueTask task1, ValueTask task2, ValueTask task3, ValueTask task4)
- public static ValueTask<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>>> WhenAll<T1, T2, T3, T4>(ValueTask<T1> task1, ValueTask<T2> task2, ValueTask<T3> task3, ValueTask<T4> task4)
- public static ValueTask WhenAll(ValueTask task1, ValueTask task2, ValueTask task3, ValueTask task4, ValueTask task5)
- public static ValueTask<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>, Result<T5>>> WhenAll<T1, T2, T3, T4, T5>(ValueTask<T1> task1, ValueTask<T2> task2, ValueTask<T3> task3, ValueTask<T4> task4, ValueTask<T5> task5)
- public static Task<bool> WaitAsync(this Task task, TimeSpan timeout, CancellationToken token = default)
- public static Task<ValueTuple<T1, T2>> WhenAll<T1, T2>(Task<T1> task1, Task<T2> task2)
- public static Task<ValueTuple<T1, T2, T3>> WhenAll<T1, T2, T3>(Task<T1> task1, Task<T2> task2, Task<T3> task3)
- public static Task<ValueTuple<T1, T2, T3, T4>> WhenAll<T1, T2, T3, T4>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4)
- public static Task<ValueTuple<T1, T2, T3, T4, T5>> WhenAll<T1, T2, T3, T4, T5>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4, Task<T5> task5)

DotNext.VariantType

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

API Diff between 2.9.1 and 5.14.0

DotNext

DotNext.Buffers

DotNext.Buffers.Binary

DotNext.Buffers.Text

DotNext.Collections.Generic

DotNext.Collections.Specialized

DotNext.ComponentModel.DataAnnotations

DotNext.Diagnostics

DotNext.Generic

DotNext.IO

DotNext.IO.Hashing

DotNext.Net.Http

DotNext.Numerics

DotNext.Patterns

DotNext.Reflection

DotNext.Resources

DotNext.Runtime

DotNext.Runtime.Caching

DotNext.Runtime.CompilerServices

DotNext.Runtime.ExceptionServices

DotNext.Runtime.InteropServices

DotNext.Security.Cryptography

DotNext.Text

DotNext.Text.Json

DotNext.Threading

DotNext.Threading.Tasks

DotNext.VariantType