DotNext by Roman Sakno

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

---

API Diff between 2.5.0 and 1.0.1

472 Additions 249 Removals

DotNext

• public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : struct
  • public static int Compare<G>(T first, G second) where G : struct
  • public static bool Equals<G>(T first, G second) where G : struct
  • public static int GetHashCode(T value, bool salted = true)
  • public static int GetHashCode(T value, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode(T value, int hash, ref ValueFunc hashFunction, bool salted = true)
  • public static int Compare<TOther>(ref T first, ref TOther second) where TOther : struct
  • public static bool Equals<TOther>(ref T first, ref TOther second) where TOther : struct
  • public static int GetHashCode(ref T value, bool salted = true)
  • public static int GetHashCode(ref T value, int hash, ref ValueFunc hashFunction, bool salted)
  • public static int GetHashCode(ref T value, int hash, Func<int, int, int> hashFunction, bool salted = true)
• public static class Comparable
• public static class Comparison
  • public static bool Between<T>(this T value, T left, T right, BoundType boundType = 0) where T : IComparable<T>
  • public static T Clamp<T>(this T value, T min, T max) where T : IComparable<T>
• public static class Converter
  • public static Func<I, O> AsFunc<I, O>(this Converter<I, O> converter)
  • public static Func<TInput, TOutput> AsFunc<TInput, TOutput>(this Converter<TInput, TOutput> converter)
  • public static ValueFunc<I, O> AsValueFunc<I, O>(this Converter<I, O> converter, bool wrap = false)
  • public static Converter<I, O> Identity<I, O>() where I : O
  • public static ValueFunc<TInput, TOutput> AsValueFunc<TInput, TOutput>(this Converter<TInput, TOutput> converter, bool wrap = false)
  • public static Converter<TInput, TOutput> Identity<TInput, TOutput>() where TInput : TOutput
  • public static Result<O> TryInvoke<I, O>(this Converter<I, O> converter, I input)
  • public static Result<TOutput> TryInvoke<TInput, TOutput>(this Converter<TInput, TOutput> converter, TInput input)
• public static class DelegateHelpers
  • public static Func<R> Bind<T, R>(this Func<T, R> func, T obj)
  • public static Func<T2, R> Bind<T1, T2, R>(this Func<T1, T2, R> func, T1 obj)
  • public static Func<TResult> Bind<T, TResult>(this Func<T, TResult> func, T obj)
  • public static Func<T2, TResult> Bind<T1, T2, TResult>(this Func<T1, T2, TResult> func, T1 obj)
  • public static Func<T2, T3, R> Bind<T1, T2, T3, R>(this Func<T1, T2, T3, R> func, T1 obj)
  • public static Func<T2, T3, TResult> Bind<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> func, T1 obj)
  • public static Func<T2, T3, T4, R> Bind<T1, T2, T3, T4, R>(this Func<T1, T2, T3, T4, R> func, T1 obj)
  • public static Func<T2, T3, T4, TResult> Bind<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> func, T1 obj)
  • public static Func<T2, T3, T4, T5, R> Bind<T1, T2, T3, T4, T5, R>(this Func<T1, T2, T3, T4, T5, R> func, T1 obj)
  • public static Func<T2, T3, T4, T5, TResult> Bind<T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> func, T1 obj)
  • public static D ChangeType<D>(this Delegate d) where D : Delegate
  • public static EventHandler<O> Contravariant<I, O>(this EventHandler<I> handler) where O : I
  • public static Func<object, D> CreateClosedDelegateFactory<D>(Expression<D> expression) where D : Delegate
  • public static D CreateDelegate<D>(this MethodInfo method, object target = null) where D : Delegate
  • public static D CreateOpenDelegate<D>(Expression<D> expression) where D : Delegate
  • public static TDelegate ChangeType<TDelegate>(this Delegate d) where TDelegate : Delegate
  • public static EventHandler<T> Contravariant<TBase, T>(this EventHandler<TBase> handler) where T : TBase
  • public static Func<object, TDelegate> CreateClosedDelegateFactory<TDelegate>(Expression<TDelegate> expression) where TDelegate : Delegate
  • public static TDelegate CreateDelegate<TDelegate>(this MethodInfo method, object target = null) where TDelegate : Delegate
  • public static TDelegate CreateOpenDelegate<TDelegate>(Expression<TDelegate> expression) where TDelegate : Delegate
  • public static Func<T, R> Unbind<T, R>(this Func<R> func)
  • public static Func<G, T, R> Unbind<G, T, R>(this Func<T, R> func)
  • public static Action<G, T> Unbind<G, T>(this Action<T> action)
  • public static Func<G, T1, T2, R> Unbind<G, T1, T2, R>(this Func<T1, T2, R> func)
  • public static Action<G, T1, T2> Unbind<G, T1, T2>(this Action<T1, T2> action)
  • public static Func<G, T1, T2, T3, R> Unbind<G, T1, T2, T3, R>(this Func<T1, T2, T3, R> func)
  • public static Action<G, T1, T2, T3> Unbind<G, T1, T2, T3>(this Action<T1, T2, T3> action)
  • public static Func<G, T1, T2, T3, T4, R> Unbind<G, T1, T2, T3, T4, R>(this Func<T1, T2, T3, T4, R> func)
  • public static Action<G, T1, T2, T3, T4> Unbind<G, T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action)
  • public static Func<G, T1, T2, T3, T4, T5, R> Unbind<G, T1, T2, T3, T4, T5, R>(this Func<T1, T2, T3, T4, T5, R> func)
  • public static Action<G, T1, T2, T3, T4, T5> Unbind<G, T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action)
  • public static Func<T, TResult> Unbind<T, TResult>(this Func<TResult> func)
  • public static Func<T, TArg, TResult> Unbind<T, TArg, TResult>(this Func<TArg, TResult> func)
  • public static Action<T, TArg> Unbind<T, TArg>(this Action<TArg> action)
  • public static Func<T, T1, T2, TResult> Unbind<T, T1, T2, TResult>(this Func<T1, T2, TResult> func)
  • public static Action<T, T1, T2> Unbind<T, T1, T2>(this Action<T1, T2> action)
  • public static Func<T, T1, T2, T3, TResult> Unbind<T, T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> func)
  • public static Action<T, T1, T2, T3> Unbind<T, T1, T2, T3>(this Action<T1, T2, T3> action)
  • public static Func<T, T1, T2, T3, T4, TResult> Unbind<T, T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> func)
  • public static Action<T, T1, T2, T3, T4> Unbind<T, T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action)
  • public static Func<T, T1, T2, T3, T4, T5, TResult> Unbind<T, T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> func)
  • public static Action<T, T1, T2, T3, T4, T5> Unbind<T, T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action)
• public abstract class Disposable : IDisposable
  • public static ValueTask DisposeAsync(IEnumerable<IAsyncDisposable> objects)
  • public static ValueTask DisposeAsync(IAsyncDisposable[] objects)
• public struct Enum<TEnum> : IEquatable<TEnum>, IComparable<TEnum>, IFormattable, IEquatable<Enum<TEnum>>, ISerializable, IConvertible<TEnum> where TEnum : struct, Enum
  • public static readonly Enum<E> MaxValue
  • public static readonly Enum<E> MinValue
  • public static IReadOnlyList<Enum<E>> Members { get; }
  • public static readonly Enum<TEnum> MaxValue
  • public static readonly Enum<TEnum> MinValue
  • public static IReadOnlyList<Enum<TEnum>> Members { get; }
  • public E Value { get; }
  • public static Enum<E> GetMember(E value)
  • public static Enum<E> GetMember(string name)
  • public static bool IsDefined(E value)
  • 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 op_Equality(Enum<E> first, Enum<E> second)
  • public static E op_Implicit(ref Enum en)
  • public static bool op_Inequality(Enum<E> first, Enum<E> second)
  • public static bool TryGetMember(E value, out Enum member)
  • public static bool TryGetMember(string name, out Enum member)
  • public int CompareTo(E other)
  • public bool Equals(E other)
  • public bool Equals(Enum<E> other)
  • 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 bool IsOneOf<T>(this T value, T[] values) where T : struct, Enum
• public struct EnumerableTuple<TItem, TTuple> : IReadOnlyList<TItem>, IEnumerable<TItem>, IEnumerable, IReadOnlyCollection<TItem> where TTuple : ITuple
  • public I this[int index] { get; }
  • public Enumerator<I, T> GetEnumerator()
  • public TItem this[int index] { get; }
  • public int CopyTo(Span<TItem> output)
  • public Enumerator<TItem, TTuple> GetEnumerator()
• public static class Func
  • public static Converter<I, O> AsConverter<I, O>(this Func<I, O> function)
  • public static Converter<TInput, TOutput> AsConverter<TInput, TOutput>(this Func<TInput, TOutput> function)
  • public static Func<I, O> Identity<I, O>() where I : O
  • public static Func<TInput, TOutput> Identity<TInput, TOutput>() where TInput : TOutput
  • public static Result<R> TryInvoke<R>(this Func<R> function)
  • public static Result<R> TryInvoke<T, R>(this Func<T, R> function, T arg)
  • public static Result<R> TryInvoke<T1, T2, R>(this Func<T1, T2, R> function, T1 arg1, T2 arg2)
  • public static Result<R> TryInvoke<T1, T2, T3, R>(this Func<T1, T2, T3, R> function, T1 arg1, T2 arg2, T3 arg3)
  • public static Result<R> TryInvoke<T1, T2, T3, T4, R>(this Func<T1, T2, T3, T4, R> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
  • public static Result<R> TryInvoke<T1, T2, T3, T4, T5, R>(this Func<T1, T2, T3, T4, T5, R> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
  • public static Result<R> TryInvoke<T1, T2, T3, T4, T5, T6, R>(this Func<T1, T2, T3, T4, T5, T6, R> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
  • public static Result<R> TryInvoke<T1, T2, T3, T4, T5, T6, T7, R>(this Func<T1, T2, T3, T4, T5, T6, T7, R> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
  • public static Result<R> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, R>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, R> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
  • public static Result<R> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
  • public static Result<R> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
  • public static Result<TResult> TryInvoke<TResult>(this Func<TResult> function)
  • public static Result<TResult> TryInvoke<T, TResult>(this Func<T, TResult> function, T arg)
  • public static Result<TResult> TryInvoke<T1, T2, TResult>(this Func<T1, T2, TResult> function, T1 arg1, T2 arg2)
  • public static Result<TResult> TryInvoke<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> function, T1 arg1, T2 arg2, T3 arg3)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, TResult>(this Func<T1, T2, T3, T4, T5, T6, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, T7, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
  • public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
• public interface ICallable
  • bool IsEmpty { get; }
• public interface ICallable<TDelegate> : ICallable, IConvertible<TDelegate> where TDelegate : Delegate
  • D ToDelegate()
  • TDelegate ToDelegate()
• public interface IConvertible<T>
  • T Convert()
• public static class ObjectExtensions
  • public static void Decompose<T, R1, R2>(this T obj, Func<T, R1> decomposer1, Func<T, R2> decomposer2, out R1 result1, out R2 result2)
  • public static void Decompose<T, R1, R2>(this T obj, ref ValueFunc decomposer1, ref ValueFunc decomposer2, out R1 result1, out R2 result2)
  • public static ValueTuple<R1, R2> Decompose<T, R1, R2>(this T obj, Func<T, R1> decomposer1, Func<T, R2> decomposer2)
  • public static ValueTuple<R1, R2> Decompose<T, R1, R2>(this T obj, ref ValueFunc decomposer1, ref ValueFunc decomposer2)
  • public static void Decompose<T, TResult1, TResult2>(this T obj, Func<T, TResult1> decomposer1, Func<T, TResult2> decomposer2, out TResult1 result1, out TResult2 result2)
  • public static void Decompose<T, TResult1, TResult2>(this T obj, ref ValueFunc decomposer1, ref ValueFunc decomposer2, out TResult1 result1, out TResult2 result2)
  • public static ValueTuple<TResult1, TResult2> Decompose<T, TResult1, TResult2>(this T obj, Func<T, TResult1> decomposer1, Func<T, TResult2> decomposer2)
  • public static ValueTuple<TResult1, TResult2> Decompose<T, TResult1, TResult2>(this T obj, ref ValueFunc decomposer1, ref ValueFunc decomposer2)
• public static class OneDimensionalArray
  • public static T[] Concat<T>(this T[] left, T[] right, long startIndex)
  • public static bool SequenceEqual(this object[] first, object[] second)
  • public static bool SequenceEqual(this object[] first, object[] second, bool parallel = false)
  • public static ArraySegment<T> Slice<T>(this T[] input, ref Range range)
• public static class Optional
  • public static Task<Optional<O>> Convert<I, O>(this Task<Optional<I>> task, Converter<I, O> converter)
  • public static Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<Optional<TInput>> task, Converter<TInput, TOutput> converter)
  • public static Task<T> OrThrow<T, E>(this Task<Optional<T>> task, Func<E> exceptionFactory) where E : Exception
  • public static Task<T> OrThrow<T, TException>(this Task<Optional<T>> task, Func<TException> exceptionFactory) where TException : Exception
• public struct Optional<T> : IEquatable<Optional<T>>, IEquatable<T>, IStructuralEquatable, ISerializable
  • public bool IsPresent { get; }
  • public bool HasValue { get; }
  • public Optional<U> Convert<U>(ref ValueFunc mapper)
  • public Optional<U> Convert<U>(Converter<T, U> mapper)
  • public Optional<U> Convert<U>(ref ValueFunc mapper)
  • public Optional<U> Convert<U>(Converter<T, Optional<U>> mapper)
  • public Optional<object> Box()
  • public Optional<TResult> Convert<TResult>(ref ValueFunc mapper)
  • public Optional<TResult> Convert<TResult>(Converter<T, TResult> mapper)
  • public Optional<TResult> Convert<TResult>(ref ValueFunc mapper)
  • public Optional<TResult> Convert<TResult>(Converter<T, Optional<TResult>> mapper)
  • public bool Equals(ref Optional other)
  • public bool Equals(Optional<T> other)
  • public T OrThrow<E>(ref ValueFunc exceptionFactory) where E : Exception
  • public T OrThrow<E>(Func<E> exceptionFactory) where E : Exception
  • public T OrThrow<TException>(ref ValueFunc exceptionFactory) where TException : Exception
  • public T OrThrow<TException>(Func<TException> exceptionFactory) where TException : Exception
• public static class RandomExtensions
  • public static T Next<T>(this Random random) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static T Next<T>(this RandomNumberGenerator random) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public sealed delegate RefFunc<T, TArgs, TResult> : MulticastDelegate
  • public RefFunc(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ref T reference, TArgs args, AsyncCallback callback, object object)
  • public virtual TResult EndInvoke(ref T reference, IAsyncResult result)
  • public virtual TResult Invoke(ref T reference, TArgs args)
• public struct Result<T> : ISerializable
  • public Result<U> Convert<U>(ref ValueFunc converter)
  • public Result<U> Convert<U>(Converter<T, U> converter)
  • public Result<object> Box()
  • public Result<TResult> Convert<TResult>(ref ValueFunc converter)
  • public Result<TResult> Convert<TResult>(Converter<T, TResult> converter)
  • public Optional<T> TryGet()
• public static class Sequence
  • public struct LimitedEnumerator<T> : IEnumerator<T>, IEnumerator, IDisposable
  • 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 LimitedEnumerator<T> Limit<T>(this IEnumerator<T> enumerator, int count, bool leaveOpen = false)
  • public static bool Skip<TEnumerator, T>(this ref TEnumerator enumerator, int count) where TEnumerator : struct, IEnumerator<T>
• public static class Span
  • public static Span<byte> AsBytes<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static Span<byte> AsBytes<T>(T* pointer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static ReadOnlySpan<byte> AsReadOnlyBytes<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int FromHex(this ReadOnlySpan<char> chars, Span<byte> output)
  • public static byte[] FromHex(this ReadOnlySpan<char> chars)
  • public static T Read<T>(ref ReadOnlySpan bytes) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • 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 void Write<T>(ref T value, ref Span output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public static class StringExtensions
  • public static string Substring(this string str, Range range)
• public struct UserDataSlot<TValue> : IEquatable<UserDataSlot<TValue>>
  • public static UserDataSlot<V> Allocate()
  • public static bool op_Equality(UserDataSlot<V> first, UserDataSlot<V> second)
  • public static bool op_Inequality(UserDataSlot<V> first, UserDataSlot<V> second)
  • public bool Equals(UserDataSlot<V> other)
  • public static UserDataSlot<TValue> Allocate()
  • public static bool op_Equality(UserDataSlot<TValue> first, UserDataSlot<TValue> second)
  • public static bool op_Inequality(UserDataSlot<TValue> first, UserDataSlot<TValue> second)
  • public bool Equals(UserDataSlot<TValue> other)
• public struct UserDataStorage
  • public interface IContainer
  • public V Get<V>(UserDataSlot<V> slot, V defaultValue = null)
  • public V GetOrSet<V>(UserDataSlot<V> slot)
  • public B GetOrSet<B, D>(UserDataSlot<B> slot) where D : B
  • public V GetOrSet<V>(UserDataSlot<V> slot, Func<V> valueFactory)
  • public V GetOrSet<T, V>(UserDataSlot<V> slot, T arg, Func<T, V> valueFactory)
  • public V GetOrSet<T1, T2, V>(UserDataSlot<V> slot, T1 arg1, T2 arg2, Func<T1, T2, V> valueFactory)
  • public V GetOrSet<V>(UserDataSlot<V> slot, ref ValueFunc valueFactory)
  • public V GetOrSet<T, V>(UserDataSlot<V> slot, T arg, ref ValueFunc valueFactory)
  • public V GetOrSet<T1, T2, V>(UserDataSlot<V> slot, T1 arg1, T2 arg2, ref ValueFunc valueFactory)
  • public bool Remove<V>(UserDataSlot<V> slot)
  • public bool Remove<V>(UserDataSlot<V> slot, out V userData)
  • public void Set<V>(UserDataSlot<V> slot, V userData)
  • public bool TryGet<V>(UserDataSlot<V> slot, out V userData)
  • public void CopyTo(object obj)
  • public TValue Get<TValue>(UserDataSlot<TValue> slot, TValue defaultValue)
  • public TValue Get<TValue>(UserDataSlot<TValue> slot)
  • public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot)
  • public TBase GetOrSet<TBase, T>(UserDataSlot<TBase> slot) where T : TBase
  • public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot, Func<TValue> valueFactory)
  • public TValue GetOrSet<T, TValue>(UserDataSlot<TValue> slot, T arg, Func<T, TValue> valueFactory)
  • public TValue GetOrSet<T1, T2, TValue>(UserDataSlot<TValue> slot, T1 arg1, T2 arg2, Func<T1, T2, TValue> valueFactory)
  • public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot, ref ValueFunc valueFactory)
  • public TValue GetOrSet<T, TValue>(UserDataSlot<TValue> slot, T arg, ref ValueFunc valueFactory)
  • public TValue GetOrSet<T1, T2, TValue>(UserDataSlot<TValue> slot, T1 arg1, T2 arg2, ref ValueFunc valueFactory)
  • public bool Remove<TValue>(UserDataSlot<TValue> slot)
  • public bool Remove<TValue>(UserDataSlot<TValue> slot, out TValue userData)
  • public void Set<TValue>(UserDataSlot<TValue> slot, TValue userData)
  • public bool TryGet<TValue>(UserDataSlot<TValue> slot, out TValue userData)
• public struct ValueAction : IValueDelegate<Action>, ICallable<Action>, ICallable, IConvertible<Action>, ISupplier<Action>, IEquatable<ValueAction>
  • public bool Equals(ref ValueAction other)
  • public bool Equals(ValueAction other)
• public struct ValueAction<T> : IValueDelegate<Action<T>>, ICallable<Action<T>>, ICallable, IConvertible<Action<T>>, ISupplier<Action<T>>, IEquatable<ValueAction<T>>, IConsumer<T>
  • public bool Equals(ref ValueAction other)
  • public bool Equals(ValueAction<T> other)
• 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 Equals(ref ValueAction other)
  • public bool Equals(ValueAction<T1, T2> other)
• 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 Equals(ref ValueAction other)
  • public bool Equals(ValueAction<T1, T2, T3> other)
• 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 Equals(ref ValueAction other)
  • public bool Equals(ValueAction<T1, T2, T3, T4> other)
• 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 Equals(ref ValueAction other)
  • public bool Equals(ValueAction<T1, T2, T3, T4, T5> other)
• 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<R> Activator { get; }
  • public static ValueFunc<R> DefaultValueProvider { get; }
  • public static ValueFunc<TResult> Activator { get; }
  • public static ValueFunc<TResult> DefaultValueProvider { get; }
  • public ValueFunc(Func<R> func, bool wrap = false)
  • public ValueFunc(Func<TResult> func, bool wrap = false)
  • public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
  • public static Func<R> op_Explicit(ref ValueFunc pointer)
  • public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
  • public bool Equals(ref ValueFunc other)
  • public R Invoke()
  • public Func<R> ToDelegate()
  • 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 ValueFunc(Func<T, R> func, bool wrap = false)
  • public ValueFunc(Func<T, TResult> func, bool wrap = false)
  • public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
  • public static Func<T, R> op_Explicit(ref ValueFunc func)
  • public static Converter<T, R> op_Explicit(ref ValueFunc func)
  • public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
  • public bool Equals(ref ValueFunc other)
  • public R Invoke(T arg)
  • public Func<T, R> ToDelegate()
  • 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 ValueFunc(Func<T1, T2, R> func, bool wrap = false)
  • public ValueFunc(Func<T1, T2, TResult> func, bool wrap = false)
  • public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
  • public static Func<T1, T2, R> op_Explicit(ref ValueFunc pointer)
  • public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
  • public bool Equals(ref ValueFunc other)
  • public R Invoke(T1 arg1, T2 arg2)
  • public Func<T1, T2, R> ToDelegate()
  • 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 ValueFunc(Func<T1, T2, T3, R> func, bool wrap = false)
  • public ValueFunc(Func<T1, T2, T3, TResult> func, bool wrap = false)
  • public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
  • public static Func<T1, T2, T3, R> op_Explicit(ref ValueFunc pointer)
  • public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
  • public bool Equals(ref ValueFunc other)
  • public R Invoke(T1 arg1, T2 arg2, T3 arg3)
  • public Func<T1, T2, T3, R> ToDelegate()
  • 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 ValueFunc(Func<T1, T2, T3, T4, R> func, bool wrap = false)
  • public ValueFunc(Func<T1, T2, T3, T4, TResult> func, bool wrap = false)
  • public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
  • public static Func<T1, T2, T3, T4, R> op_Explicit(ref ValueFunc pointer)
  • public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
  • public bool Equals(ref ValueFunc other)
  • public R Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
  • public Func<T1, T2, T3, T4, R> ToDelegate()
  • 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 ValueFunc(Func<T1, T2, T3, T4, T5, R> func, bool wrap = false)
  • public ValueFunc(Func<T1, T2, T3, T4, T5, TResult> func, bool wrap = false)
  • public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
  • public static Func<T1, T2, T3, T4, T5, R> op_Explicit(ref ValueFunc pointer)
  • public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
  • public bool Equals(ref ValueFunc other)
  • public R Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
  • public Func<T1, T2, T3, T4, T5, R> ToDelegate()
  • 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 static bool op_Equality(ref ValueRefAction first, ref ValueAction second)
  • public static bool op_Equality(ref ValueRefAction first, ref ValueRefAction second)
  • public static bool op_Inequality(ref ValueRefAction first, ref ValueAction second)
  • public bool Equals(ref ValueRefAction other)
  • public static bool op_Inequality(ref ValueRefAction first, ref ValueRefAction second)
  • public bool Equals(ValueRefAction<T, TArgs> other)
• 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 float EnsureFinite(this float value)
  • public static double EnsureFinite(this double value)
  • public static IntPtr Remainder(this IntPtr x, IntPtr y)
  • public static UIntPtr Remainder(this UIntPtr x, UIntPtr y)
  • public static byte ToByte(this bool value)
  • public static bool TryGet<T>(this ref Nullable nullable, out T value) where T : struct
  • public static int Truncate(this long value)
  • public static bool TryGetValue<T>(this T? nullable, out T value) where T : struct

DotNext.Buffers

• public struct ArrayRental<T> : IMemoryOwner<T>, IDisposable, IConvertible<Memory<T>>, IConvertible<ArraySegment<T>>, IConvertible<MemoryOwner<T>>
  • public int Length { get; }
  • public MemoryOwner<T> Owner { get; }
  • public ArraySegment<T> Segment { get; }
  • public Span<T> Span { get; }
  • public ArrayRental(ArrayPool<T> pool, int minimumLength)
  • public static T[] op_Implicit(ref ArrayRental rental)
  • 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 static class ChunkSequence
  • public static Task CopyToAsync(this ChunkSequence<byte> sequence, Stream output, CancellationToken token = default)
  • public static Task CopyToAsync(this ChunkSequence<char> sequence, TextWriter output, CancellationToken token = default)
  • 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 class MemoryAllocator
  • 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 sealed delegate MemoryAllocator<T> : MulticastDelegate
  • public MemoryAllocator(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(int length, AsyncCallback callback, object object)
  • public virtual MemoryOwner<T> EndInvoke(IAsyncResult result)
  • public virtual MemoryOwner<T> Invoke(int length)
• public struct MemoryOwner<T> : IMemoryOwner<T>, IDisposable, IConvertible<Memory<T>>
  • public bool IsEmpty { get; }
  • public ref T this[int index] { get; }
  • public int Length { get; }
  • public Memory<T> Memory { get; }
  • public MemoryOwner(ArrayPool<T> pool, int length)
  • public MemoryOwner(MemoryPool<T> pool, int length = -1)
  • public MemoryOwner(T[] array, int length)
  • public MemoryOwner(T[] array)
  • public void Dispose()
• 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 abstract class MemoryWriter<T> : Disposable, IBufferWriter<T>, IConvertible<ReadOnlyMemory<T>>
  • public abstract int Capacity { get; }
  • public int FreeCapacity { get; }
  • public int WrittenCount { get; }
  • public abstract ReadOnlyMemory<T> WrittenMemory { get; }
  • public void Advance(int count)
  • public abstract void Clear()
  • 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>>
  • public ArraySegment<T> WrittenArray { get; }
  • public PooledArrayBufferWriter(ArrayPool<T> pool, int initialCapacity)
  • public PooledArrayBufferWriter(ArrayPool<T> pool)
  • public PooledArrayBufferWriter()
  • 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.Collections.Concurrent

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

DotNext.Collections.Generic

• public static class Collection
  • public static ReadOnlyCollectionView<I, O> Convert<I, O>(this IReadOnlyCollection<I> collection, ref ValueFunc converter)
  • public static ReadOnlyCollectionView<I, O> Convert<I, O>(this IReadOnlyCollection<I> collection, Converter<I, O> converter)
  • public static ReadOnlyCollectionView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyCollection<TInput> collection, ref ValueFunc converter)
  • public static ReadOnlyCollectionView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyCollection<TInput> collection, Converter<TInput, TOutput> converter)
• public static class Dictionary
  • public static ReadOnlyDictionaryView<K, V, T> ConvertValues<K, V, T>(this IReadOnlyDictionary<K, V> dictionary, ref ValueFunc mapper)
  • public static ReadOnlyDictionaryView<K, V, T> ConvertValues<K, V, T>(this IReadOnlyDictionary<K, V> dictionary, Converter<V, T> mapper)
  • public static void Deconstruct<K, V>(this KeyValuePair<K, V> pair, out K key, out V value)
  • public static void ForEach<K, V>(this IDictionary<K, V> dictionary, ref ValueAction action)
  • public static void ForEach<K, V>(this IDictionary<K, V> dictionary, Action<K, V> action)
  • public static V GetOrAdd<K, V>(this Dictionary<K, V> dictionary, K key)
  • public static V GetOrAdd<K, V>(this Dictionary<K, V> dictionary, K key, V value)
  • public static V GetOrAdd<K, V>(this Dictionary<K, V> dictionary, K key, ref ValueFunc valueFactory)
  • public static V GetOrAdd<K, V>(this Dictionary<K, V> dictionary, K key, Func<K, V> valueFactory)
  • public static V GetOrInvoke<K, V>(this IDictionary<K, V> dictionary, K key, ref ValueFunc defaultValue)
  • public static V GetOrInvoke<K, V>(this IDictionary<K, V> dictionary, K key, Func<V> defaultValue)
  • public static Func<K, V> IndexerGetter<K, V>(this IReadOnlyDictionary<K, V> dictionary)
  • public static Func<K, V> IndexerGetter<K, V>(this IDictionary<K, V> dictionary)
  • public static Action<K, V> IndexerSetter<K, V>(this IDictionary<K, V> dictionary)
  • public static Optional<V> TryGetValue<K, V>(this IDictionary<K, V> dictionary, K key)
  • public static Optional<V> TryGetValue<K, V>(IReadOnlyDictionary<K, V> dictionary, K key)
  • public static Optional<V> TryRemove<K, V>(this IDictionary<K, V> dictionary, K key)
  • public static ReadOnlyDictionaryView<TKey, TValue, TResult> ConvertValues<TKey, TValue, TResult>(this IReadOnlyDictionary<TKey, TValue> dictionary, ref ValueFunc mapper)
  • public static ReadOnlyDictionaryView<TKey, TValue, TResult> ConvertValues<TKey, TValue, TResult>(this IReadOnlyDictionary<TKey, TValue> dictionary, Converter<TValue, TResult> mapper)
  • public static void ForEach<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, ref ValueAction action)
  • public static void ForEach<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, Action<TKey, TValue> action)
  • public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key)
  • public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key, TValue value)
  • public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key, ref ValueFunc valueFactory)
  • public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TValue> valueFactory)
  • public static TValue GetOrInvoke<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, ref ValueFunc defaultValue)
  • public static TValue GetOrInvoke<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, Func<TValue> defaultValue)
  • public static Func<TKey, TValue> IndexerGetter<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary)
  • public static Func<TKey, TValue> IndexerGetter<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
  • public static Action<TKey, TValue> IndexerSetter<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
  • public static Optional<TValue> TryGetValue<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
  • public static Optional<TValue> TryGetValue<TKey, TValue>(IReadOnlyDictionary<TKey, TValue> dictionary, TKey key)
  • public static Optional<TValue> TryRemove<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
• public static class List
  • public static ReadOnlyListView<I, O> Convert<I, O>(this IReadOnlyList<I> list, ref ValueFunc converter)
  • public static ReadOnlyListView<I, O> Convert<I, O>(this IReadOnlyList<I> list, Converter<I, O> converter)
  • public static ReadOnlyListView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyList<TInput> list, ref ValueFunc converter)
  • public static ReadOnlyListView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyList<TInput> list, Converter<TInput, TOutput> converter)
  • public static void Insert<T>(this IList<T> list, Index index, T item)
  • public static void RemoveAt<T>(this IList<T> list, Index index)
  • public static void RemoveRange<T>(this List<T> list, Range range)
  • public static O[] ToArray<I, O>(this IList<I> input, ref ValueFunc mapper)
  • public static O[] ToArray<I, O>(this IList<I> input, Converter<I, O> mapper)
  • public static O[] ToArray<I, O>(this IList<I> input, ref ValueFunc mapper)
  • public static O[] ToArray<I, O>(this IList<I> input, Func<int, I, O> mapper)
  • public static ListSegment<T> Slice<T>(this IList<T> list, Range range)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, ref ValueFunc mapper)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, Converter<TInput, TOutput> mapper)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, ref ValueFunc mapper)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, Func<int, TInput, TOutput> mapper)
• public struct ListSegment<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyList<T>, IReadOnlyCollection<T>
  • public int Count { get; }
  • public T this[int index] { get; set; }
  • public ListSegment(IList<T> list, Range range)
  • public bool Contains(T item)
  • public void CopyTo(T[] array, int arrayIndex)
  • public IEnumerator<T> GetEnumerator()
  • public int IndexOf(T item)
• public struct ReadOnlyCollectionView<TInput, TOutput> : IReadOnlyCollection<TOutput>, IEnumerable<TOutput>, IEnumerable, IEquatable<ReadOnlyCollectionView<TInput, TOutput>>
  • public ReadOnlyCollectionView(IReadOnlyCollection<I> collection, ref ValueFunc mapper)
  • public static bool op_Equality(ReadOnlyCollectionView<I, O> first, ReadOnlyCollectionView<I, O> second)
  • public static bool op_Inequality(ReadOnlyCollectionView<I, O> first, ReadOnlyCollectionView<I, O> second)
  • public bool Equals(ReadOnlyCollectionView<I, O> other)
  • public IEnumerator<O> GetEnumerator()
  • public ReadOnlyCollectionView(IReadOnlyCollection<TInput> collection, 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 bool Equals(ReadOnlyCollectionView<TInput, TOutput> other)
  • public IEnumerator<TOutput> GetEnumerator()
• public struct ReadOnlyDictionaryView<TKey, TInput, TOutput> : IReadOnlyDictionary<TKey, TOutput>, IEnumerable<KeyValuePair<TKey, TOutput>>, IEnumerable, IReadOnlyCollection<KeyValuePair<TKey, TOutput>>, IEquatable<ReadOnlyDictionaryView<TKey, TInput, TOutput>>
  • public O this[K key] { get; }
  • public IEnumerable<K> Keys { get; }
  • public IEnumerable<O> Values { get; }
  • public ReadOnlyDictionaryView(IReadOnlyDictionary<K, I> dictionary, ref ValueFunc mapper)
  • public static bool op_Equality(ReadOnlyDictionaryView<K, I, O> first, ReadOnlyDictionaryView<K, I, O> second)
  • public static bool op_Inequality(ReadOnlyDictionaryView<K, I, O> first, ReadOnlyDictionaryView<K, I, O> second)
  • public bool ContainsKey(K key)
  • public bool Equals(ReadOnlyDictionaryView<K, I, O> other)
  • public IEnumerator<KeyValuePair<K, O>> GetEnumerator()
  • public bool TryGetValue(K key, out O value)
  • public TOutput this[TKey key] { get; }
  • public IEnumerable<TKey> Keys { get; }
  • public IEnumerable<TOutput> Values { get; }
  • public ReadOnlyDictionaryView(IReadOnlyDictionary<TKey, TInput> dictionary, 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 bool ContainsKey(TKey key)
  • public bool Equals(ReadOnlyDictionaryView<TKey, TInput, TOutput> other)
  • public IEnumerator<KeyValuePair<TKey, TOutput>> GetEnumerator()
  • public bool TryGetValue(TKey key, out TOutput value)
• public struct ReadOnlyListView<TInput, TOutput> : IReadOnlyList<TOutput>, IEnumerable<TOutput>, IEnumerable, IReadOnlyCollection<TOutput>, IEquatable<ReadOnlyListView<TInput, TOutput>>
  • public O this[int index] { get; }
  • public ReadOnlyListView(IReadOnlyList<I> list, ref ValueFunc mapper)
  • public static bool op_Equality(ReadOnlyListView<I, O> first, ReadOnlyListView<I, O> second)
  • public static bool op_Inequality(ReadOnlyListView<I, O> first, ReadOnlyListView<I, O> second)
  • public bool Equals(ReadOnlyListView<I, O> other)
  • public IEnumerator<O> GetEnumerator()
  • public TOutput this[int index] { get; }
  • public ReadOnlyListView(IReadOnlyList<TInput> list, 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 bool Equals(ReadOnlyListView<TInput, TOutput> other)
  • public IEnumerator<TOutput> GetEnumerator()

DotNext.Diagnostics

• public sealed class UnreachableCodeExecutionException : Exception
  • public UnreachableCodeExecutionException()

DotNext.Generic

• public abstract class Constant<T> : IConvertible<T>
  • public T Value { get; }
• public abstract class IntConst : Constant<int>
• public abstract class LongConst : Constant<long>
• public abstract class Int32Const : Constant<int>
  • public sealed class Max : Int32Const
  • public sealed class Min : Int32Const
  • public sealed class Zero : Int32Const
  • protected Int32Const(int value)
• public abstract class Int64Const : Constant<long>
  • public sealed class Max : Int64Const
  • public sealed class Min : Int64Const
  • public sealed class Zero : Int64Const
  • protected Int64Const(long value)

DotNext.IO

• public static class StreamExtensions
• public sealed class StreamSegment : Stream
• public interface IFlushable
  • void Flush()
  • Task FlushAsync(CancellationToken token = default)
• public static class StreamSource
  • public static Stream AsStream(this ReadOnlySequence<byte> sequence)
  • public static Stream AsStream(this ReadOnlyMemory<byte> memory)
  • public static Stream AsStream<TWriter>(this TWriter writer, Action<TWriter> flush = null, Func<TWriter, CancellationToken, Task> flushAsync = null) where TWriter : IBufferWriter<byte>
  • public static Stream GetWrittenBytesAsStream(this PooledArrayBufferWriter<byte> writer)

DotNext.Net.NetworkInformation

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

DotNext.Reflection

• public static class CustomAttribute
  • public static bool IsDefined<A>(this MemberInfo member, bool inherit = false) where A : Attribute
  • public static bool IsDefined<A>(this Module module) where A : Attribute
  • public static bool IsDefined<A>(this Assembly assembly) where A : Attribute
  • public static bool IsDefined<A>(this ParameterInfo parameter) where A : Attribute
  • public static bool IsDefined<TAttribute>(this ICustomAttributeProvider member, bool inherit = false) where TAttribute : Attribute
• public static class TypeExtensions
  • public static MethodInfo GetMethod(this Type type, string methodName, BindingFlags flags, long genericParamCount, Type[] parameters)
  • public static MethodInfo GetMethod(this Type type, string name, BindingFlags flags, Type[] parameters)

DotNext.Runtime

• public static class Intrinsics
  • public static IntPtr AddressOf<T>(ref T value)
  • public static bool AreSame<T>(ref T first, ref T second)
  • public static ref T AsRef<T>(this TypedReference reference)
  • public static T Cast<T>(object obj)
  • public static void ClearBits(Void* address, long length)
  • public static int Compare(Void* first, Void* second, long length)
  • public static void Copy<T>(ref T input, out T output) where T : struct
  • public static void Copy<T>(T* input, T* output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Copy<T>(ref T source, ref T destination, long count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void CopyUnaligned<T>(T* input, T* output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static bool IsDefault<T>(T value)
  • 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 IsDefault<T>(ref T value)
  • public static bool IsExactTypeOf<T>(object obj)
  • public static bool IsNull<T>(ref T value)
  • public static void Reverse<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Swap<T>(ref T first, ref T second)
  • public static void Swap<T>(T* first, T* second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Throw(object obj)
  • public static void ThrowIfNull<T>(ref T value)
  • public static RuntimeTypeHandle TypeOf<T>()

DotNext.Runtime.CompilerServices

• 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)

DotNext.Runtime.InteropServices

• public static class Memory

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 struct DecodingContext
• public struct EncodingContext

DotNext.Threading

• public static class AsyncDelegate
  • public static AsyncDelegateFuture InvokeAsync<D>(this D delegate, Action<D> invoker, CancellationToken token = default) where D : MulticastDelegate
  • public static AsyncDelegateFuture InvokeAsync<E>(this EventHandler<E> handler, object sender, E args, 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 struct Atomic<T> : IStrongBox, ICloneable where T : struct
  • public void Clone(out Atomic container)
  • public Atomic<T> Clone()
  • public void CompareExchange(ref T update, ref T expected, out T result)
  • public bool CompareExchange(ref T update, ref T expected, out T result)
• public static class AtomicEnum
  • public static E VolatileRead<E>(this ref E value) where E : struct, Enum
  • public static void VolatileWrite<E>(this ref E value, E newValue) where E : struct, Enum
  • 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 E Value { get; set; }
  • public AtomicEnum(E value)
  • public E AccumulateAndGet(E x, Func<E, E, E> accumulator)
  • public E AccumulateAndGet(E x, ref ValueFunc accumulator)
  • public bool CompareAndSet(E expected, E update)
  • public E CompareExchange(E update, E expected)
  • public bool Equals(E other)
  • public E GetAndAccumulate(E x, Func<E, E, E> accumulator)
  • public E GetAndAccumulate(E x, ref ValueFunc accumulator)
  • public E GetAndSet(E update)
  • public E GetAndUpdate(Func<E, E> updater)
  • public E GetAndUpdate(ref ValueFunc updater)
  • public E SetAndGet(E update)
  • public E UpdateAndGet(Func<E, E> updater)
  • public E UpdateAndGet(ref ValueFunc updater)
  • 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 struct ReaderWriterSpinLock
  • public struct LockStamp : IEquatable<LockStamp>
  • public int CurrentReadCount { get; }
  • public bool IsReadLockHeld { get; }
  • public bool IsWriteLockHeld { get; }
  • public void EnterReadLock()
  • public void EnterWriteLock()
  • public void ExitReadLock()
  • public void ExitWriteLock()
  • public bool TryEnterReadLock()
  • public bool TryEnterReadLock(TimeSpan timeout, CancellationToken token = default)
  • public bool TryEnterWriteLock()
  • public bool TryEnterWriteLock(TimeSpan timeout, CancellationToken token = default)
  • public LockStamp TryOptimisticRead()
  • public bool Validate(ref LockStamp stamp)
• public struct Timeout
  • public bool IsInfinite { get; }
  • public TimeSpan? RemainingTime { get; }
  • public TimeSpan Value { get; }

DotNext.Threading.Tasks

• public static class Continuation
  • public static Task<Task<R>> OnCompleted<R>(this Task<R> task)
  • public static Task<Task<TResult>> OnCompleted<TResult>(this Task<TResult> task)
• public static class Conversion
  • public static Task<O> Convert<I, O>(this Task<I> task) where I : O
  • public static Task<O> Convert<I, O>(this Task<I> task, Converter<I, O> converter)
  • public static Task<O> Convert<I, O>(this Task<I> task, Converter<I, Task<O>> converter)
  • public static DynamicTaskAwaitable AsDynamic(this Task task)
  • public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task) where TInput : TOutput
  • public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task, Converter<TInput, TOutput> converter)
  • public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task, Converter<TInput, Task<TOutput>> converter)
• public struct DynamicTaskAwaitable
  • public struct Awaiter : IFuture, INotifyCompletion
  • public DynamicTaskAwaitable ConfigureAwait(bool continueOnCaptureContext)
  • public Awaiter GetAwaiter()
• public static class Synchronization
  • public static Result<R> GetResult<R>(this Task<R> task, TimeSpan timeout)
  • public static Result<R> GetResult<R>(this Task<R> task, CancellationToken token)
  • public static Result<TResult> GetResult<TResult>(this Task<TResult> task, TimeSpan timeout)
  • public static Result<TResult> GetResult<TResult>(this Task<TResult> task, CancellationToken token)
  • public static Result<object> GetResult(this Task task, CancellationToken token)
  • public static Result<object> GetResult(this Task task, TimeSpan timeout)

DotNext.VariantType

• public interface IVariant : IDynamicMetaObjectProvider
  • bool Equals<V>(V other) where V : IVariant
  • bool Equals<TVariant>(TVariant other) where TVariant : IVariant
• public struct Variant<T1, T2> : IEquatable<Variant<T1, T2>>, IVariant, IDynamicMetaObjectProvider
  • public Optional<R> Convert<R>(Converter<T1, R> mapper1, Converter<T2, R> mapper2)
  • public Variant<U1, U2> Convert<U1, U2>(Converter<T1, U1> mapper1, Converter<T2, U2> mapper2)
  • public bool Equals<V>(V other) where V : IVariant
  • public Optional<TResult> Convert<TResult>(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 struct Variant<T1, T2, T3> : IVariant, IDynamicMetaObjectProvider, IEquatable<Variant<T1, T2, T3>>
  • public bool Equals<V>(V other) where V : IVariant
  • public void Deconstruct(out T1 value1, out T2 value2, out T3 value3)
  • public bool Equals<TOther>(TOther other) where TOther : IVariant
• public struct Variant<T1, T2, T3, T4> : IVariant, IDynamicMetaObjectProvider, IEquatable<Variant<T1, T2, T3, T4>>
  • public bool Equals<V>(V other) where V : IVariant
  • public void Deconstruct(out T1 value1, out T2 value2, out T3 value3, out T4 value4)
  • public bool Equals<TOther>(TOther other) where TOther : IVariant