DotNext by Roman Sakno

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

---

API Diff between 0.5.1 and 1.2.9

133 Additions 323 Removals

DotNext

• public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : struct
• public static class Comparable
  • 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 Comparison
• public static class Converter
  • public static ValueFunc<I, O> AsValueFunc<I, O>(this Converter<I, O> converter, bool wrap = false)
  • public static Result<O> TryInvoke<I, O>(this Converter<I, O> converter, I input)
• public static class DelegateHelpers
  • public static Action Bind<T>(this Action<T> action, T obj)
  • 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 Action<T2> Bind<T1, T2>(this Action<T1, T2> action, T1 obj)
  • public static Func<T2, T3, R> Bind<T1, T2, T3, R>(this Func<T1, T2, T3, R> func, T1 obj)
  • public static Action<T2, T3> Bind<T1, T2, T3>(this Action<T1, T2, T3> action, T1 obj)
  • public static Func<T2, T3, T4, R> Bind<T1, T2, T3, T4, R>(this Func<T1, T2, T3, T4, R> func, T1 obj)
  • public static Action<T2, T3, T4> Bind<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T1 obj)
  • public static Func<T2, T3, T4, T5, R> Bind<T1, T2, T3, T4, T5, R>(this Func<T1, T2, T3, T4, T5, R> func, T1 obj)
  • public static Action<T2, T3, T4, T5> Bind<T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action, T1 obj)
  • public static Func<object, D> CreateClosedDelegateFactory<D>(Expression<D> expression) where D : Delegate
  • public static D CreateOpenDelegate<D>(Expression<D> expression) where D : Delegate
  • public static Action<T> Unbind<T>(this Action action)
  • 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 abstract class Disposable : IDisposable
  • protected static void QueueDispose(IDisposable resource)
• public struct Enum<E> : IEquatable<E>, IComparable<E>, IFormattable, IComparable<Enum<E>> where E : struct, Enum
  • public static bool op_Equality(Enum<E> first, Enum<E> second)
  • public static bool op_Inequality(Enum<E> first, Enum<E> second)
  • public bool Equals(Enum<E> other)
  • public bool HasFlag(E flag)
• public static class EnumerableTuple
• public struct EnumerableTuple<I, T> : IReadOnlyList<I>, IEnumerable<I>, IEnumerable, IReadOnlyCollection<I> where T : IStructuralEquatable, IStructuralComparable
• public struct EqualityComparerBuilder<T>
• public static class EqualityComparerBuilder
  • public static IEqualityComparer<T> Build<T>()
  • public static Func<T, T, bool> BuildEquals<T>()
  • public static Func<T, int> BuildGetHashCode<T>(bool salted = true)
• public static class Func
  • public static Func<T, bool> IsNotNull<T>()
  • public static Func<T, bool> IsNull<T>()
  • 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 interface ICallable
• public interface ICallable<D> : ICallable where D : Delegate
• public interface IOptional
  • bool IsPresent { get; }
• public sealed delegate ItemAction<I, V> : MulticastDelegate
  • public ItemAction(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(I index, ref V element, AsyncCallback callback, object object)
  • public virtual void EndInvoke(ref V element, IAsyncResult result)
  • public virtual void Invoke(I index, ref V element)
• public static class ObjectExtensions
  • 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, ref ValueFunc decomposer1, ref ValueFunc decomposer2)
• public static class OneDimensionalArray
  • public static int BitwiseHashCode<T>(this T[] array, int hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this T[] array) 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 void ForEach<T>(this T[] array, ref ValueRefAction action)
  • public static void ForEach<T>(this T[] array, RefAction<T, long> action)
  • public static O[] ConvertAll<I, O>(this I[] input, Func<long, I, O> mapper)
  • public static void ForEach<T>(this T[] array, ItemAction<long, T> action)
  • public static 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 bool SequenceEqual<T>(this T[] first, T[] second) where T : IEquatable<T>
• public static class Optional
  • public static Optional<T> EmptyIfNull<T>(this T value)
  • public static Task<T?> OrNull<T>(this Task<Optional<T>> task) where T : struct
• public struct Optional<T> : IOptional, IEquatable<Optional<T>>, IEquatable<T>, IStructuralEquatable
  • public static bool HasValue(ref T value)
  • public Optional<U> Convert<U>(ref ValueFunc mapper)
  • public Optional<U> Convert<U>(ref ValueFunc mapper)
  • public bool Equals(Optional<T> other)
  • public bool Equals(ref Optional other)
  • public Optional<T> If(ref ValueFunc condition)
  • public T OrInvoke(ref ValueFunc defaultFunc)
  • public T OrThrow<E>(ref ValueFunc exceptionFactory) where E : Exception
• public static class Predicate
  • public static ValueFunc<T, bool> AsValueFunc<T>(this Predicate<T> predicate, bool wrap = false)
  • public static Predicate<T?> HasValue<T>() where T : struct
  • public static Result<bool> TryInvoke<T>(this Predicate<T> predicate, T obj)
• public sealed delegate RefAction<T, TArgs> : MulticastDelegate
• public sealed delegate RefFunc<T, TArgs, TResult> : MulticastDelegate
• public static class Range
  • 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 T LowerBounded<T>(this T value, T min) where T : IComparable<T>
  • public static T UpperBounded<T>(this T value, T max) where T : IComparable<T>
• public static class Result
• public struct Result<T> : ISerializable
• public static class Sequence
  • public static IEnumerable<T> Append<T>(this IEnumerable<T> collection, T[] items)
  • public static void ForEach<T>(this IEnumerable<T> collection, ref ValueAction action)
  • public static IEnumerable<T> Prepend<T>(this IEnumerable<T> collection, T[] items)
• public static class Span
• public static class StringExtensions
  • public static Char& modreq(System.Runtime.InteropServices.InAttribute) GetRawData(this string str)
  • public static ChunkSequence<char> Split(this string str, int chunkSize)
• public struct UserDataStorage
  • public B GetOrSet<B, D>(UserDataSlot<B> slot) where D : B
  • 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 struct ValueAction : ICallable<Action>, ICallable, IEquatable<ValueAction>
• public struct ValueAction<T> : ICallable<Action<T>>, ICallable, IEquatable<ValueAction<T>>, IConsumer<T>
• public struct ValueAction<T1, T2> : ICallable<Action<T1, T2>>, ICallable, IEquatable<ValueAction<T1, T2>>
• public struct ValueAction<T1, T2, T3> : ICallable<Action<T1, T2, T3>>, ICallable, IEquatable<ValueAction<T1, T2, T3>>
• public struct ValueAction<T1, T2, T3, T4> : ICallable<Action<T1, T2, T3, T4>>, ICallable, IEquatable<ValueAction<T1, T2, T3, T4>>
• public struct ValueAction<T1, T2, T3, T4, T5> : ICallable<Action<T1, T2, T3, T4, T5>>, ICallable, IEquatable<ValueAction<T1, T2, T3, T4, T5>>
• public struct ValueFunc<R> : ICallable<Func<R>>, ICallable, IEquatable<ValueFunc<R>>, ISupplier<R>
• public struct ValueFunc<T, R> : ICallable<Func<T, R>>, ICallable, ICallable<Converter<T, R>>, IEquatable<ValueFunc<T, R>>
• public struct ValueFunc<T1, T2, R> : ICallable<Func<T1, T2, R>>, ICallable, IEquatable<ValueFunc<T1, T2, R>>, ISupplier<T1, T2, R>
• public struct ValueFunc<T1, T2, T3, R> : ICallable<Func<T1, T2, T3, R>>, ICallable, IEquatable<ValueFunc<T1, T2, T3, R>>
• public struct ValueFunc<T1, T2, T3, T4, R> : ICallable<Func<T1, T2, T3, T4, R>>, ICallable, IEquatable<ValueFunc<T1, T2, T3, T4, R>>
• public struct ValueFunc<T1, T2, T3, T4, T5, R> : ICallable<Func<T1, T2, T3, T4, T5, R>>, ICallable, IEquatable<ValueFunc<T1, T2, T3, T4, T5, R>>
• public struct ValueRefAction<T, TArgs> : ICallable<RefAction<T, TArgs>>, ICallable, IEquatable<ValueRefAction<T, TArgs>>
• public struct ValueRefFunc<T, TArgs, TResult> : ICallable<RefFunc<T, TArgs, TResult>>, ICallable, IEquatable<ValueRefFunc<T, TArgs, TResult>>
• public sealed class ValueType<T> : StrongBox<T> where T : struct
  • public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : struct
  • public static readonly bool IsPrimitive
  • public static T Default { get; }
  • public static int Size { get; }
  • public ValueType(T value)
  • public static byte[] AsBinary(T value)
  • public static void BitCast<TO>(ref T input, out TO output) where TO : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseCompare(T first, T second)
  • public static int BitwiseCompare<U>(T first, U second) where U : struct
  • public static bool BitwiseEquals<U>(T first, U second) where U : struct
  • public static bool BitwiseEquals(T first, T second)
  • public static int BitwiseHashCode(T value, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int BitwiseHashCode(T value, bool salted)
  • public static int BitwiseHashCode(T value)
  • public static bool IsDefault(T value)
  • public static T op_Implicit(ValueType<T> box)
  • public ref T GetPinnableReference()
• 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 void BitCast<FROM, TO>(this FROM input, out TO output) where FROM : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where TO : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static TO BitCast<FROM, TO>(this FROM input) where FROM : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where TO : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static ValueType<T> Box<T>(this T value) where T : struct
  • public static 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 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 int ToInt32(this bool value)
  • public static IntPtr ToIntPtr(this UIntPtr value)
  • public static UIntPtr ToUIntPtr(this IntPtr value)
  • public static bool TryGet<T>(this ref Nullable nullable, out T value) where T : struct
  • public static IntPtr Xor(this IntPtr x, IntPtr y)
  • public static UIntPtr Xor(this UIntPtr x, UIntPtr y)

DotNext.Buffers

• public struct ArrayRental<T> : IDisposable
  • public bool IsEmpty { get; }
  • public ref T this[long index] { get; }
  • public int Length { get; }
  • public Memory<T> Memory { get; }
  • public ArraySegment<T> Segment { get; }
  • public Span<T> Span { get; }
  • public ArrayRental(int minimumLength, bool clearArray = false)
  • public ArrayRental(T[] array, int length)
  • public ArrayRental(T[] array)
  • public static T[] op_Explicit(ref ArrayRental rental)
  • public static T[] op_Implicit(ref ArrayRental rental)
  • public ref T GetPinnableReference()
  • public ArraySegment<T> Slice(int offset, int count)
• public static class ChunkSequence
• public struct ChunkSequence<T> : IEnumerable<ReadOnlyMemory<T>>, IEnumerable
• public struct MemoryRental<T>

DotNext.Collections.Concurrent

• public class CopyOnWriteList<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IList<T>, ICollection<T>, ICloneable
  • public struct Enumerator<T> : IEnumerator<T>, IEnumerator, IDisposable
  • public ReadOnlyMemory<T> Snapshot { get; }
  • public void Clear(ref ValueAction cleaner)
  • public void Clear(Action<T> cleaner)
  • public Enumerator<T> GetEnumerator()
  • public Enumerator<T> GetEnumerator()
  • public long RemoveAll(ValueFunc<T, bool> match)
  • public void RemoveAll(ref ValueFunc match, ref ValueAction callback)
  • public void RemoveAll(Predicate<T> match, Action<T> callback)
  • public void Set(ReadOnlySpan<T> array)
  • public void Set<G>(ICollection<G> items, ref ValueFunc converter)
  • public void Set<G>(ICollection<G> items, Converter<G, T> converter)

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<T> AsReadOnlyView<T>(this ICollection<T> collection)
• 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 ReadOnlyDictionaryView<K, V> AsReadOnlyView<K, V>(this IDictionary<K, V> dictionary)
  • public static ReadOnlyDictionaryView<K, V, T> Convert<K, V, T>(this IReadOnlyDictionary<K, V> dictionary, Converter<V, T> mapper)
  • public static Optional<T> ConvertValue<K, V, T>(this IDictionary<K, V> dictionary, K key, Converter<V, T> mapper)
  • public static bool ConvertValue<K, V, T>(this IDictionary<K, V> dictionary, K key, Converter<V, T> mapper, out T value)
  • public static void ForEach<K, V>(this IDictionary<K, V> dictionary, ref ValueAction 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, ref ValueFunc valueFactory)
  • public static V GetOrInvoke<K, V>(this IDictionary<K, V> dictionary, K key, ref ValueFunc defaultValue)
  • 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 class List
  • public static ReadOnlyListView<I, O> Convert<I, O>(this IReadOnlyList<I> list, ref ValueFunc converter)
  • public static ReadOnlyListView<T> AsReadOnlyView<T>(this IList<T> list)
  • 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, Comparison<T> comparer)
  • public static O[] ToArray<I, O>(this IList<I> input, ref ValueFunc mapper)
  • public static O[] ToArray<I, O>(this IList<I> input, ref ValueFunc mapper)
• public struct ReadOnlyCollectionView<T> : IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, IEquatable<ReadOnlyCollectionView<T>>
  • public int Count { get; }
  • public ReadOnlyCollectionView(ICollection<T> collection)
  • public static bool op_Equality(ReadOnlyCollectionView<T> first, ReadOnlyCollectionView<T> second)
  • public static bool op_Inequality(ReadOnlyCollectionView<T> first, ReadOnlyCollectionView<T> second)
  • public bool Contains(T item)
  • public bool Equals(ReadOnlyCollectionView<T> other)
  • public IEnumerator<T> GetEnumerator()
• public struct ReadOnlyCollectionView<I, O> : IReadOnlyCollection<O>, IEnumerable<O>, IEnumerable, IEquatable<ReadOnlyCollectionView<I, O>>
  • public ReadOnlyCollectionView(IReadOnlyCollection<I> collection, ref ValueFunc mapper)
  • public ReadOnlyCollectionView(IReadOnlyCollection<I> collection, Converter<I, O> mapper)
• public struct ReadOnlyDictionaryView<K, V> : IReadOnlyDictionary<K, V>, IEnumerable<KeyValuePair<K, V>>, IEnumerable, IReadOnlyCollection<KeyValuePair<K, V>>, IEquatable<ReadOnlyDictionaryView<K, V>>
  • public int Count { get; }
  • public V this[K key] { get; }
  • public IEnumerable<K> Keys { get; }
  • public IEnumerable<V> Values { get; }
  • public ReadOnlyDictionaryView(IDictionary<K, V> dictionary)
  • public static bool op_Equality(ReadOnlyDictionaryView<K, V> first, ReadOnlyDictionaryView<K, V> second)
  • public static bool op_Inequality(ReadOnlyDictionaryView<K, V> first, ReadOnlyDictionaryView<K, V> second)
  • public bool ContainsKey(K key)
  • public bool Equals(ReadOnlyDictionaryView<K, V> other)
  • public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
  • public bool TryGetValue(K key, out V value)
• public struct ReadOnlyDictionaryView<K, I, O> : IReadOnlyDictionary<K, O>, IEnumerable<KeyValuePair<K, O>>, IEnumerable, IReadOnlyCollection<KeyValuePair<K, O>>, IEquatable<ReadOnlyDictionaryView<K, I, O>>
  • public ReadOnlyDictionaryView(IReadOnlyDictionary<K, I> dictionary, ref ValueFunc mapper)
  • public ReadOnlyDictionaryView(IReadOnlyDictionary<K, I> dictionary, Converter<I, O> mapper)
• public struct ReadOnlyListView<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IEquatable<ReadOnlyListView<T>>
  • public int Count { get; }
  • public T this[int index] { get; }
  • public ReadOnlyListView(IList<T> list)
  • public static bool op_Equality(ReadOnlyListView<T> first, ReadOnlyListView<T> second)
  • public static bool op_Inequality(ReadOnlyListView<T> first, ReadOnlyListView<T> second)
  • public bool Contains(T item)
  • public bool Equals(ReadOnlyListView<T> other)
  • public IEnumerator<T> GetEnumerator()
  • public int IndexOf(T item)
• public struct ReadOnlyListView<I, O> : IReadOnlyList<O>, IEnumerable<O>, IEnumerable, IReadOnlyCollection<O>, IEquatable<ReadOnlyListView<I, O>>
  • public ReadOnlyListView(IReadOnlyList<I> list, ref ValueFunc mapper)
  • public ReadOnlyListView(IReadOnlyList<I> list, Converter<I, O> mapper)

DotNext.Diagnostics

• public struct Timestamp : IEquatable<Timestamp>, IComparable<Timestamp>

DotNext.Generic

• public abstract class Constant<T>
  • public static T Of<G>(bool intern = true) where G : Constant<T>
• public sealed class DefaultConst<T> : Constant<T>

DotNext.IO

• public static class StreamExtensions
• public sealed class StreamSegment : Stream

DotNext.Reflection

• public static class CollectionType
  • public static Type GetImplementedCollection(this Type type)
• public static class CustomAttribute
• public static class Conversion<I, O>
  • public static readonly Converter<I, O> Converter
  • public static readonly bool IsSupported
• public static class MethodExtensions
• public static class Method
  • public static Type[] GetParameterTypes(this MethodBase method)
  • public static bool SignatureEquals(this MethodBase method, Type[] parameters)
  • public static bool SignatureEquals(this MethodBase method, MethodBase other)
  • public static bool SignatureEquals(this MethodInfo method, MethodInfo other)
• public static class TypeExtensions
  • public static MethodInfo Devirtualize(this Type type, MethodInfo abstractMethod)
  • public static TypeCode GetTypeCode(this Type t)
  • public static bool IsImmutable(this Type type)

DotNext.Runtime

• public static class Intrinsics

DotNext.Runtime.CompilerServices

• public abstract class AsyncDelegateFuture : Future<Task>, IAwaiter, IFuture, INotifyCompletion
• public struct ManagedMethodPointer : IEquatable<ManagedMethodPointer>
• public sealed class RuntimeFeaturesAttribute : Attribute

DotNext.Runtime.InteropServices

• public static class Memory
  • public static readonly Void* NullPtr
  • public static ref T AsRef<T>(this TypedReference reference)
  • public static Span<byte> AsSpan<T>(T* pointer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void ClearBits(Void* address, long length)
  • public static void Copy<T>(ref T source, ref T destination, uint count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • 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 int GetHashCode32(IntPtr source, long length, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode32(IntPtr source, long length, int hash, ref ValueFunc hashFunction, bool salted = true)
  • public static int GetHashCode32(Void* source, long length, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode32(Void* source, long length, int hash, ref ValueFunc hashFunction, bool salted = true)
  • public static int GetHashCode32(IntPtr source, long length, bool salted = true)
  • public static int GetHashCode32(Void* source, long length, bool salted = true)
  • public static long GetHashCode64(IntPtr source, long length, long hash, Func<long, long, long> hashFunction, bool salted = true)
  • public static long GetHashCode64(IntPtr source, long length, long hash, ref ValueFunc hashFunction, 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(IntPtr source, long length, 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 bool IsNull<T>(ref T value)
  • public static long GetHashCode(IntPtr source, long length, long hash, Func<long, long, long> hashFunction, bool salted = true)
  • public static long GetHashCode(Void* source, long length, long hash, Func<long, long, long> hashFunction, bool salted = true)
  • public static int GetHashCode(IntPtr source, long length, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode(Void* source, long length, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode(IntPtr source, long length, bool salted = true)
  • public static int GetHashCode(Void* source, long length, bool salted = true)
  • public static string ReadString(ref IntPtr source)
  • 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 ThrowIfNull<T>(ref T value)
  • public static T* ToPointer<T>(this UIntPtr source) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void WriteString(ref IntPtr destination, ReadOnlySpan<char> str)
  • public static void WriteString(ref IntPtr destination, string str)
  • public static void ZeroMem(Void* ptr, long length)

DotNext.Text

• public struct DecodingContext
• public struct EncodingContext
• public static class EncodingExtensions

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(this EventHandler handler, object sender, EventArgs args, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync(this Action action, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T>(this Action<T> action, T arg, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2>(this Action<T1, T2> action, T1 arg1, T2 arg2, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3>(this Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6>(this Action<T1, T2, T3, T4, T5, T6> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6, T7>(this Action<T1, T2, T3, T4, T5, T6, T7> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Action<T1, T2, T3, T4, T5, T6, T7, T8> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, CancellationToken token = default)
  • public static Task InvokeAsync<D>(this D delegate, Action<D> invoker, CancellationToken token = default) where D : MulticastDelegate
  • public static Task InvokeAsync<E>(this EventHandler<E> handler, object sender, E args, CancellationToken token = default)
  • public static Task InvokeAsync(this EventHandler handler, object sender, EventArgs args, CancellationToken token = default)
  • public static Task InvokeAsync(this Action action, CancellationToken token = default)
  • public static Task InvokeAsync<T>(this Action<T> action, T arg, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2>(this Action<T1, T2> action, T1 arg1, T2 arg2, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3>(this Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4, T5, T6>(this Action<T1, T2, T3, T4, T5, T6> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7>(this Action<T1, T2, T3, T4, T5, T6, T7> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Action<T1, T2, T3, T4, T5, T6, T7, T8> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, CancellationToken token = default)
  • public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, CancellationToken token = default)
• public struct Atomic<T> : IStrongBox, ICloneable where T : struct
• public struct AtomicBoolean : IEquatable<bool>
  • public bool AccumulateAndGet(bool x, ref ValueFunc accumulator)
  • public bool GetAndAccumulate(bool x, Func<bool, bool, bool> accumulator)
  • public bool GetAndAccumulate(bool x, ref ValueFunc accumulator)
  • public bool GetAndAcummulate(bool x, Func<bool, bool, bool> accumulator)
  • public bool GetAndUpdate(ref ValueFunc updater)
  • public bool UpdateAndGet(ref ValueFunc updater)
• public static class AtomicDouble
  • public static double AccumulateAndGet(this ref double value, double x, ref ValueFunc accumulator)
  • public static double AccumulateAndGet(this double[] array, long index, double x, ref ValueFunc accumulator)
  • public static double CompareExchange(this double[] array, long index, double update, double comparand)
  • public static long CompareExchange(this long[] array, long index, long update, long comparand)
  • public static double GetAndAccumulate(this ref double value, double x, ref ValueFunc accumulator)
  • public static double GetAndAccumulate(this double[] array, long index, double x, ref ValueFunc accumulator)
  • public static double GetAndUpdate(this ref double value, ref ValueFunc updater)
  • public static double GetAndUpdate(this double[] array, long index, ref ValueFunc updater)
  • public static double UpdateAndGet(this ref double value, ref ValueFunc updater)
  • public static double UpdateAndGet(this double[] array, long index, ref ValueFunc updater)
• public static class AtomicEnum
• public struct AtomicEnum<E> : IEquatable<E>, ISerializable where E : struct, Enum
• public static class AtomicInt32
  • public static int AccumulateAndGet(this ref int value, int x, ref ValueFunc accumulator)
  • public static int AccumulateAndGet(this int[] array, long index, int x, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static int GetAndUpdate(this ref int value, ref ValueFunc updater)
  • public static int GetAndUpdate(this int[] array, long index, ref ValueFunc updater)
  • public static int UpdateAndGet(this ref int value, ref ValueFunc updater)
  • public static int UpdateAndGet(this int[] array, long index, ref ValueFunc updater)
• public static class AtomicInt64
  • public static long AccumulateAndGet(this ref long value, long x, ref ValueFunc accumulator)
  • public static long AccumulateAndGet(this long[] array, long index, long x, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static long GetAndUpdate(this ref long value, ref ValueFunc updater)
  • public static long GetAndUpdate(this long[] array, long index, ref ValueFunc updater)
  • public static long UpdateAndGet(this ref long value, ref ValueFunc updater)
  • public static long UpdateAndGet(this long[] array, long index, ref ValueFunc updater)
• public static class AtomicIntPtr
• public static class AtomicReference
  • 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, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static T GetAndUpdate<T>(ref T value, ref ValueFunc updater)
  • public static T GetAndUpdate<T>(this T[] array, long index, ref ValueFunc updater)
  • public static T UpdateAndGet<T>(ref T value, ref ValueFunc updater)
  • public static T UpdateAndGet<T>(this T[] array, long index, ref ValueFunc updater)
• public struct AtomicReference<T> : IEquatable<T>
  • public T AccumulateAndGet(T x, ref ValueFunc accumulator)
  • public T GetAndAccumulate(T x, ref ValueFunc accumulator)
  • public T GetAndUpdate(ref ValueFunc updater)
  • public T UpdateAndGet(ref ValueFunc updater)
• public static class AtomicSingle
  • public static float AccumulateAndGet(this ref float value, float x, ref ValueFunc accumulator)
  • public static float AccumulateAndGet(this float[] array, long index, float x, ref ValueFunc 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, ref ValueFunc accumulator)
  • public static float GetAndUpdate(this ref float value, ref ValueFunc updater)
  • public static float GetAndUpdate(this float[] array, long index, ref ValueFunc updater)
  • public static float UpdateAndGet(this ref float value, ref ValueFunc updater)
  • public static float UpdateAndGet(this float[] array, long index, ref ValueFunc updater)
• public static class LockAcquisition
  • public static Holder AcquireLock(this SemaphoreSlim semaphore)
  • public static Holder AcquireLock(this SemaphoreSlim semaphore, TimeSpan timeout)
  • public static Holder AcquireReadLock(this ReaderWriterLockSlim rwLock)
  • public static Holder AcquireReadLock(this ReaderWriterLockSlim rwLock, TimeSpan timeout)
  • public static Holder AcquireUpgradeableReadLock(this ReaderWriterLockSlim rwLock)
  • public static Holder AcquireUpgradeableReadLock(this ReaderWriterLockSlim rwLock, TimeSpan timeout)
  • public static Holder AcquireWriteLock(this ReaderWriterLockSlim rwLock)
  • public static Holder AcquireWriteLock(this ReaderWriterLockSlim rwLock, TimeSpan timeout)
• public struct ReaderWriterSpinLock
• public struct Timeout
  • public bool IsExpired { get; }
  • public bool Expired { get; }
  • public void ThrowIfExpired(out TimeSpan remaining)

DotNext.Threading.Tasks

• public static class Continuation
• public static class Conversion
  • public static Task<O> Convert<I, O>(this Task<I> task) where I : O
  • public static Task<T?> ToNullable<T>(this Task<T> task) where T : struct
• public abstract class Future : IFuture, INotifyCompletion
• public abstract class Future<T> : Future where T : Task
• public interface IFuture : INotifyCompletion
• 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 Task<bool> WaitAsync(this Task task, TimeSpan timeout, CancellationToken token = default)
  • public static R GetResult<R>(this Task<R> task, TimeSpan timeout)
  • public static R GetResult<R>(this Task<R> task, CancellationToken token)

DotNext.VariantType

• public struct Variant<T1, T2> : IEquatable<Variant<T1, T2>>, IVariant, IDynamicMetaObjectProvider, IOptional
  • public bool IsNull { get; }
  • public bool IsPresent { get; }
  • public Optional<R> Convert<R>(ref ValueFunc mapper1, ref ValueFunc mapper2)
  • public Variant<U1, U2> Convert<U1, U2>(ref ValueFunc mapper1, ref ValueFunc mapper2)
  • public void Deconstruct(out T1 value1, out T2 value2)
• public struct Variant<T1, T2, T3> : IVariant, IDynamicMetaObjectProvider, IOptional, IEquatable<Variant<T1, T2, T3>>
  • public bool IsNull { get; }
  • public bool IsPresent { get; }
  • public void Deconstruct(out T1 value1, out T2 value2, out T3 value3)
• public struct Variant<T1, T2, T3, T4> : IVariant, IDynamicMetaObjectProvider, IOptional, IEquatable<Variant<T1, T2, T3, T4>>
  • public bool IsNull { get; }
  • public bool IsPresent { get; }
  • public void Deconstruct(out T1 value1, out T2 value2, out T3 value3, out T4 value4)