DotNext by Roman Sakno

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

---

API Diff between 2.4.2 and 3.2.0

484 Additions 313 Removals

DotNext

• public struct Activator<T> : ISupplier<T>
• public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : struct
  • public static int GetHashCode(ref T value, int hash, ref ValueFunc hashFunction, bool salted)
  • public static int GetHashCode(ref T value, int hash, method hashFunction, bool salted = true)
• public static class Comparison
  • public static ValueFunc<T, T, int> AsValueFunc<T>(this Comparison<T> comparison, bool wrap = false)
• public struct Consumer<T> : IConsumer<T>
• public struct ConsumerClosure<TContext, T> : IConsumer<T>
• public static class Converter
  • public static ValueFunc<TInput, TOutput> AsValueFunc<TInput, TOutput>(this Converter<TInput, TOutput> converter, bool wrap = false)
• public static class DelegateHelpers
  • public static RefAction<T, TArgs> CreateDelegate<T, TArgs>(method ptr)
  • public static RefAction<TRef, TArgs> CreateDelegate<T, TRef, TArgs>(method ptr, T obj)
  • public static RefFunc<T, TArgs, TResult> CreateDelegate<T, TArgs, TResult>(method ptr)
  • public static RefFunc<TRef, TArgs, TResult> CreateDelegate<T, TRef, TArgs, TResult>(method ptr, T obj)
  • public static Action CreateDelegate(method ptr)
  • public static Action CreateDelegate<T>(method ptr, T obj)
  • public static Action<T> CreateDelegate<T>(method ptr)
  • public static Action<T1> CreateDelegate<T, T1>(method ptr, T obj)
  • public static Func<TResult> CreateDelegate<TResult>(method ptr)
  • public static Func<TResult> CreateDelegate<T, TResult>(method ptr, T obj)
  • public static Action<T1, T2> CreateDelegate<T1, T2>(method ptr)
  • public static Action<T1, T2> CreateDelegate<T, T1, T2>(method ptr, T obj)
  • public static Func<T, TResult> CreateDelegate<T, TResult>(method ptr)
  • public static Func<TArg, TResult> CreateDelegate<T, TArg, TResult>(method ptr, T obj)
  • public static Action<T1, T2, T3> CreateDelegate<T1, T2, T3>(method ptr)
  • public static Action<T1, T2, T3> CreateDelegate<T, T1, T2, T3>(method ptr, T obj)
  • public static Func<T1, T2, TResult> CreateDelegate<T1, T2, TResult>(method ptr)
  • public static Func<T1, T2, TResult> CreateDelegate<T, T1, T2, TResult>(method ptr, T obj)
  • public static Action<T1, T2, T3, T4> CreateDelegate<T1, T2, T3, T4>(method ptr)
  • public static Action<T1, T2, T3, T4> CreateDelegate<T, T1, T2, T3, T4>(method ptr, T obj)
  • public static Func<T1, T2, T3, TResult> CreateDelegate<T1, T2, T3, TResult>(method ptr)
  • public static Func<T1, T2, T3, TResult> CreateDelegate<T, T1, T2, T3, TResult>(method ptr, T obj)
  • public static Action<T1, T2, T3, T4, T5> CreateDelegate<T1, T2, T3, T4, T5>(method ptr)
  • public static Action<T1, T2, T3, T4, T5> CreateDelegate<T, T1, T2, T3, T4, T5>(method ptr, T obj)
  • public static Func<T1, T2, T3, T4, TResult> CreateDelegate<T1, T2, T3, T4, TResult>(method ptr)
  • public static Func<T1, T2, T3, T4, TResult> CreateDelegate<T, T1, T2, T3, T4, TResult>(method ptr, T obj)
  • public static Action<T1, T2, T3, T4, T5, T6> CreateDelegate<T1, T2, T3, T4, T5, T6>(method ptr)
  • public static Action<T1, T2, T3, T4, T5, T6> CreateDelegate<T, T1, T2, T3, T4, T5, T6>(method ptr, T obj)
  • public static Func<T1, T2, T3, T4, T5, TResult> CreateDelegate<T1, T2, T3, T4, T5, TResult>(method ptr)
  • public static Func<T1, T2, T3, T4, T5, TResult> CreateDelegate<T, T1, T2, T3, T4, T5, TResult>(method ptr, T obj)
  • public static Func<T1, T2, T3, T4, T5, T6, TResult> CreateDelegate<T1, T2, T3, T4, T5, T6, TResult>(method ptr)
  • public static Func<T1, T2, T3, T4, T5, T6, TResult> CreateDelegate<T, T1, T2, T3, T4, T5, T6, TResult>(method ptr, T obj)
  • public static ReadOnlySpanAction<T, TArg> CreateDelegate<T, TArg>(method ptr)
  • public static ReadOnlySpanAction<TItem, TArg> CreateDelegate<T, TItem, TArg>(method ptr, T obj)
  • public static SpanAction<T, TArg> CreateDelegate<T, TArg>(method ptr)
  • public static SpanAction<TItem, TArg> CreateDelegate<T, TItem, TArg>(method ptr, T obj)
  • public static Action<T, TValue> CreateOpenDelegate<T, TValue>(Expression<Func<T, TValue>> properyExpr)
• public struct DelegatingConsumer<T> : IConsumer<T>
• public struct DelegatingSupplier<TResult> : ISupplier<TResult>, IEquatable<DelegatingSupplier<TResult>>
• public struct DelegatingSupplier<T, TResult> : ISupplier<T, TResult>, IEquatable<DelegatingSupplier<T, TResult>>
• public struct DelegatingSupplier<T1, T2, TResult> : ISupplier<T1, T2, TResult>, IEquatable<DelegatingSupplier<T1, T2, TResult>>
• public abstract class Disposable : IDisposable
  • protected Task DisposedTask { get; }
  • protected static void QueueDispose(IDisposable resource)
  • protected ValueTask DisposeAsync(bool continueOnCapturedContext)
  • protected virtual ValueTask DisposeAsyncCore()
  • protected Task<T> GetDisposedTask<T>()
  • protected bool TrySetDisposedException<T>(TaskCompletionSource<T> source)
• public struct Enum<TEnum> : IEquatable<TEnum>, IComparable<TEnum>, IFormattable, IEquatable<Enum<TEnum>>, ISerializable, IConvertible<TEnum> where TEnum : struct, Enum
  • public static readonly Enum<TEnum> MaxValue
  • public static readonly Enum<TEnum> MinValue
  • public static IReadOnlyList<Enum<TEnum>> Members { get; }
  • public static Type UnderlyingType { get; }
  • public static TypeCode UnderlyingTypeCode { get; }
  • public string Name { get; }
  • public TEnum Value { get; }
  • public static Enum<TEnum> GetMember(TEnum value)
  • public static Enum<TEnum> GetMember(string name)
  • public static bool IsDefined(TEnum value)
  • public static bool IsDefined(string name)
  • public static bool op_Equality(Enum<TEnum> first, Enum<TEnum> second)
  • public static TEnum op_Implicit(ref Enum en)
  • public static bool op_Inequality(Enum<TEnum> first, Enum<TEnum> second)
  • public static bool TryGetMember(TEnum value, out Enum member)
  • public static bool TryGetMember(string name, out Enum member)
  • public int CompareTo(TEnum other)
  • public bool Equals(TEnum other)
  • public bool Equals(Enum<TEnum> other)
  • public bool IsFlag(TEnum flags)
• public static class EnumerableTuple
  • public static EnumerableTuple<T, ValueTuple<T>> AsEnumerable<T>(this ValueTuple<T> tuple)
  • public static EnumerableTuple<T, Tuple<T>> AsEnumerable<T>(this Tuple<T> tuple)
  • public static EnumerableTuple<T, ValueTuple<T, T>> AsEnumerable<T>(this ValueTuple<T, T> tuple)
  • public static EnumerableTuple<T, Tuple<T, T>> AsEnumerable<T>(this Tuple<T, T> tuple)
  • public static EnumerableTuple<T, ValueTuple<T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T> tuple)
  • public static EnumerableTuple<T, Tuple<T, T, T>> AsEnumerable<T>(this Tuple<T, T, T> tuple)
  • public static EnumerableTuple<T, ValueTuple<T, T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T, T> tuple)
  • public static EnumerableTuple<T, Tuple<T, T, T, T>> AsEnumerable<T>(this Tuple<T, T, T, T> tuple)
  • public static EnumerableTuple<T, ValueTuple<T, T, T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T, T, T> tuple)
  • public static EnumerableTuple<T, Tuple<T, T, T, T, T>> AsEnumerable<T>(this Tuple<T, T, T, T, T> tuple)
  • public static EnumerableTuple<T, ValueTuple<T, T, T, T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T, T, T, T> tuple)
  • public static EnumerableTuple<T, Tuple<T, T, T, T, T, T>> AsEnumerable<T>(this Tuple<T, T, T, T, T, T> tuple)
  • public static EnumerableTuple<T, ValueTuple<T, T, T, T, T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T, T, T, T, T> tuple)
  • public static EnumerableTuple<T, Tuple<T, T, T, T, T, T, T>> AsEnumerable<T>(this Tuple<T, T, T, T, T, T, T> tuple)
• public struct EnumerableTuple<TItem, TTuple> : IReadOnlyList<TItem>, IEnumerable<TItem>, IEnumerable, IReadOnlyCollection<TItem> where TTuple : ITuple
  • public struct Enumerator<TItem, TTuple> : IEnumerator<TItem>, IEnumerator, IDisposable where TTuple : ITuple
  • public int Count { get; }
  • public TItem this[int index] { get; }
  • public int CopyTo(Span<TItem> output)
  • public Enumerator<TItem, TTuple> GetEnumerator()
• public static class Func
  • public static Func<T> Constant<T>(T obj)
• public interface IConsumer<T>
• public interface ICallable
  • object Target { get; }
  • object DynamicInvoke(object[] args)
• public interface ICallable<TDelegate> : ICallable, IConvertible<TDelegate> where TDelegate : Delegate
  • TDelegate ToDelegate()
• public interface IConvertible<T>
  • T Convert()
• public interface ISupplier<TResult>
• public interface ISupplier<T, TResult>
• public interface ISupplier<T1, T2, TResult>
• public static class ObjectExtensions
  • public static T As<T>(this T obj)
  • public static void Decompose<T, TResult1, TResult2>(this T obj, Func<T, TResult1> decomposer1, Func<T, TResult2> decomposer2, out TResult1 result1, out TResult2 result2)
  • public static void Decompose<T, TResult1, TResult2>(this T obj, ref ValueFunc decomposer1, ref ValueFunc decomposer2, out TResult1 result1, out TResult2 result2)
  • public static ValueTuple<TResult1, TResult2> Decompose<T, TResult1, TResult2>(this T obj, Func<T, TResult1> decomposer1, Func<T, TResult2> decomposer2)
  • public static ValueTuple<TResult1, TResult2> Decompose<T, TResult1, TResult2>(this T obj, ref ValueFunc decomposer1, ref ValueFunc decomposer2)
• public static 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, int hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this T[] array, long hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this T[] array, long hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void ForEach<T>(this T[] array, ref ValueRefAction action)
  • public static void ForEach<T, TArg>(this T[] array, method action, TArg arg)
  • public static T[] RemoveAll<T>(this T[] array, ref ValueFunc match, out long count)
  • public static T[] RemoveAll<T>(this T[] array, method match, out long count)
  • public static T[] RemoveAll<T>(this T[] array, ref ValueFunc match, ref ValueAction callback)
  • public static T[] RemoveAll<T>(this T[] array, method match, Action<T> callback)
  • public static ArraySegment<T> Slice<T>(this T[] input, Range range)
  • public static ArraySegment<T> Slice<T>(this T[] input, ref Range range)
• public static class Optional
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T, TException>(this ref Optional optional) where T : struct where TException : Exception
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(this ref Optional optional, Func<Exception> exceptionFactory) where T : struct
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(this ref Optional optional, method exceptionFactory) where T : struct
  • public static Optional<T> None<T>()
  • public static Optional<T> Null<T>()
  • public static Optional<T> Some<T>(T value)
• public struct Optional<T> : IEquatable<Optional<T>>, IEquatable<T>, IStructuralEquatable, ISerializable
  • public static Optional<T> None { get; }
  • public static Optional<T> Empty { get; }
  • public bool IsNull { get; }
  • public bool IsUndefined { get; }
  • public Optional<TResult> Convert<TResult>(ref ValueFunc mapper)
  • public Optional<TResult> Convert<TResult>(method mapper)
  • public Optional<TResult> Convert<TResult>(ref ValueFunc mapper)
  • public Optional<TResult> Convert<TResult>(method mapper)
  • public Optional<T> If(ref ValueFunc condition)
  • public Optional<T> If(method condition)
  • public T OrInvoke(ref ValueFunc defaultFunc)
  • public T OrInvoke(method defaultFunc)
  • public T OrThrow(Func<Exception> exceptionFactory)
  • public T OrThrow(method exceptionFactory)
  • public T OrThrow<TException>(ref ValueFunc exceptionFactory) where TException : Exception
  • public T OrThrow<TException>(Func<TException> exceptionFactory) where TException : Exception
  • public bool TryGet(out T value, out bool isNull)
• public static class Predicate
  • public static ValueFunc<T, bool> AsValueFunc<T>(this Predicate<T> predicate, bool wrap = false)
• public static class RandomExtensions
  • public static string NextString(this Random random, char[] allowedChars, int length)
  • public static string NextString(this RandomNumberGenerator random, char[] allowedChars, int length)
• public struct Result<T> : ISerializable
  • public static Result<T> FromOptional(ref Optional optional)
  • public static Result<T> op_Explicit(ref Optional optional)
  • public Result<TResult> Convert<TResult>(ref ValueFunc converter)
  • public Result<TResult> Convert<TResult>(method converter)
  • public T OrInvoke(ref ValueFunc defaultFunc)
  • public T OrInvoke(method defaultFunc)
  • public T OrInvoke(ref ValueFunc defaultFunc)
  • public T OrInvoke(method defaultFunc)
• public static class ServiceProviderFactory
• public static class Sequence
  • public struct LimitedEnumerator<T> : IEnumerator<T>, IEnumerator, IDisposable
  • public static IEnumerable<T> Append<T>(this IEnumerable<T> collection, T[] items)
  • public static bool ElementAt<T>(this IEnumerable<T> collection, int index, out T element)
  • public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq)
  • public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq, ref ValueFunc filter)
  • public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq, Predicate<T> filter)
  • public static T? FirstOrNull<T>(this IEnumerable<T> seq) where T : struct
  • public static void ForEach<T>(this IEnumerable<T> collection, Action<T> action)
  • public static void ForEach<T>(this IEnumerable<T> collection, ref ValueAction action)
  • public static LimitedEnumerator<T> Limit<T>(this IEnumerator<T> enumerator, int count, bool leaveOpen = false)
  • public static IEnumerable<T> Prepend<T>(this IEnumerable<T> collection, T[] items)
  • public static int SequenceHashCode(this IEnumerable<object> sequence, bool salted = true)
  • public static IEnumerable<T> Singleton<T>(T item)
  • public static bool Skip<T>(this IEnumerator<T> enumerator, int count)
  • public static bool Skip<TEnumerator, T>(this ref TEnumerator enumerator, int count) where TEnumerator : struct, IEnumerator<T>
  • public static IEnumerable<T> SkipNulls<T>(this IEnumerable<T> collection)
  • public static string ToString<T>(this IEnumerable<T> collection, string delimiter, string ifEmpty = "")
• public static class Span
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static Span<T> AsSpan<T>(this ref ValueTuple tuple)
  • public static int BitwiseHashCode<T>(this Span<T> span, int hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this Span<T> span, int hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this ReadOnlySpan<T> span, int hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int BitwiseHashCode<T>(this ReadOnlySpan<T> span, int hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this Span<T> span, long hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this Span<T> span, long hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this ReadOnlySpan<T> span, long hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static long BitwiseHashCode64<T>(this ReadOnlySpan<T> span, long hash, method hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static MemoryOwner<T> Concat<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second, MemoryAllocator<T> allocator = null)
  • public static MemoryOwner<T> Concat<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second, ReadOnlySpan<T> third, MemoryAllocator<T> allocator = null)
  • public static MemoryOwner<T> Copy<T>(this ReadOnlySpan<T> span, MemoryAllocator<T> allocator = null)
  • public static void CopyTo<T>(this ReadOnlySpan<T> source, Span<T> destination, out int writtenCount)
  • public static void CopyTo<T>(this Span<T> source, Span<T> destination, out int writtenCount)
  • public static void ForEach<T>(this Span<T> span, ref ValueRefAction action)
  • public static void ForEach<T, TArg>(this Span<T> span, method action, TArg arg)
  • public static int IndexOf<T>(this ReadOnlySpan<T> span, T value, int startIndex, ref ValueFunc comparer)
  • public static int IndexOf<T>(this ReadOnlySpan<T> span, T value, int startIndex, method comparer)
  • public static T Read<T>(ref ReadOnlySpan bytes) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Sort<T>(this Span<T> span, ref ValueFunc comparison)
  • public static void Sort<T>(this Span<T> span, method comparison)
  • public static void Write<T>(ref T value, ref Span output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public static class StringExtensions
  • public static MemoryTemplate<char> AsTemplate(this string template, string placeholder)
  • public static MemoryTemplate<char> AsTemplate(this string template, char placeholder)
  • public static Char& modreq(System.Runtime.InteropServices.InAttribute) GetRawData(this string str)
  • public static bool IsNullOrEmpty(this StringBuilder builder)
  • public static bool IsEqualIgnoreCase(this string strA, string strB)
  • public static ChunkSequence<char> Split(this string str, int chunkSize)
• public struct Supplier<TResult> : ISupplier<TResult>
• public struct Supplier<T, TResult> : ISupplier<T, TResult>
• public struct Supplier<T1, T2, TResult> : ISupplier<T1, T2, TResult>
• public struct SupplierClosure<TContext, TResult> : ISupplier<TResult>
• public struct SupplierClosure<TContext, T, TResult> : ISupplier<T, TResult>
• public struct SupplierClosure<TContext, T1, T2, TResult> : ISupplier<T1, T2, TResult>
• public static class TupleExtensions
• public struct UserDataStorage
  • public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot, method valueFactory)
  • public TValue GetOrSet<T, TValue>(UserDataSlot<TValue> slot, T arg, method valueFactory)
  • public TValue GetOrSet<T1, T2, TValue>(UserDataSlot<TValue> slot, T1 arg1, T2 arg2, method valueFactory)
  • public TValue GetOrSet<TValue, TFactory>(UserDataSlot<TValue> slot, TFactory valueFactory) where TFactory : struct, ISupplier<TValue>
  • public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot, ref ValueFunc valueFactory)
  • public TValue GetOrSet<T, TValue>(UserDataSlot<TValue> slot, T arg, ref ValueFunc valueFactory)
  • public TValue GetOrSet<T1, T2, TValue>(UserDataSlot<TValue> slot, T1 arg1, T2 arg2, ref ValueFunc valueFactory)
• public struct ValueAction : IValueDelegate<Action>, ICallable<Action>, ICallable, IConvertible<Action>, ISupplier<Action>, IEquatable<ValueAction>
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueAction(MethodInfo method)
  • public ValueAction(Action action, bool wrap = false)
  • public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueAction first, ref ValueAction second)
  • public static Action op_Explicit(ref ValueAction pointer)
  • public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
  • public bool Equals(ValueAction other)
  • public void Invoke()
  • public Action ToDelegate()
• public struct ValueAction<T> : IValueDelegate<Action<T>>, ICallable<Action<T>>, ICallable, IConvertible<Action<T>>, ISupplier<Action<T>>, IEquatable<ValueAction<T>>, IConsumer<T>
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueAction(MethodInfo method)
  • public ValueAction(Action<T> action, bool wrap = false)
  • public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueAction first, ref ValueAction second)
  • public static Action<T> op_Explicit(ref ValueAction pointer)
  • public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
  • public bool Equals(ValueAction<T> other)
  • public void Invoke(T arg)
  • public Action<T> ToDelegate()
• public struct ValueAction<T1, T2> : IValueDelegate<Action<T1, T2>>, ICallable<Action<T1, T2>>, ICallable, IConvertible<Action<T1, T2>>, ISupplier<Action<T1, T2>>, IEquatable<ValueAction<T1, T2>>
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueAction(MethodInfo method)
  • public ValueAction(Action<T1, T2> action, bool wrap = false)
  • public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueAction first, ref ValueAction second)
  • public static Action<T1, T2> op_Explicit(ref ValueAction pointer)
  • public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
  • public bool Equals(ValueAction<T1, T2> other)
  • public void Invoke(T1 arg1, T2 arg2)
  • public Action<T1, T2> ToDelegate()
• public struct ValueAction<T1, T2, T3> : IValueDelegate<Action<T1, T2, T3>>, ICallable<Action<T1, T2, T3>>, ICallable, IConvertible<Action<T1, T2, T3>>, ISupplier<Action<T1, T2, T3>>, IEquatable<ValueAction<T1, T2, T3>>
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueAction(MethodInfo method)
  • public ValueAction(Action<T1, T2, T3> action, bool wrap = false)
  • public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueAction first, ref ValueAction second)
  • public static Action<T1, T2, T3> op_Explicit(ref ValueAction pointer)
  • public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
  • public bool Equals(ValueAction<T1, T2, T3> other)
  • public void Invoke(T1 arg1, T2 arg2, T3 arg3)
  • public Action<T1, T2, T3> ToDelegate()
• public struct ValueAction<T1, T2, T3, T4> : IValueDelegate<Action<T1, T2, T3, T4>>, ICallable<Action<T1, T2, T3, T4>>, ICallable, IConvertible<Action<T1, T2, T3, T4>>, ISupplier<Action<T1, T2, T3, T4>>, IEquatable<ValueAction<T1, T2, T3, T4>>
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueAction(MethodInfo method)
  • public ValueAction(Action<T1, T2, T3, T4> action, bool wrap = false)
  • public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueAction first, ref ValueAction second)
  • public static Action<T1, T2, T3, T4> op_Explicit(ref ValueAction pointer)
  • public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
  • public bool Equals(ValueAction<T1, T2, T3, T4> other)
  • public void Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
  • public Action<T1, T2, T3, T4> ToDelegate()
• public struct ValueAction<T1, T2, T3, T4, T5> : IValueDelegate<Action<T1, T2, T3, T4, T5>>, ICallable<Action<T1, T2, T3, T4, T5>>, ICallable, IConvertible<Action<T1, T2, T3, T4, T5>>, ISupplier<Action<T1, T2, T3, T4, T5>>, IEquatable<ValueAction<T1, T2, T3, T4, T5>>
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueAction(MethodInfo method)
  • public ValueAction(Action<T1, T2, T3, T4, T5> action, bool wrap = false)
  • public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueAction first, ref ValueAction second)
  • public static Action<T1, T2, T3, T4, T5> op_Explicit(ref ValueAction pointer)
  • public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
  • public bool Equals(ValueAction<T1, T2, T3, T4, T5> other)
  • public void Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
  • public Action<T1, T2, T3, T4, T5> ToDelegate()
• public struct ValueFunc<TResult> : IValueDelegate<Func<TResult>>, ICallable<Func<TResult>>, ICallable, IConvertible<Func<TResult>>, ISupplier<Func<TResult>>, IEquatable<ValueFunc<TResult>>, ISupplier<TResult>
  • public static ValueFunc<TResult> Activator { get; }
  • public static ValueFunc<TResult> DefaultValueProvider { get; }
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueFunc(MethodInfo method)
  • public ValueFunc(Func<TResult> func, bool wrap = false)
  • public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
  • public static Func<TResult> op_Explicit(ref ValueFunc pointer)
  • public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
  • public bool Equals(ValueFunc<TResult> other)
  • public TResult Invoke()
  • public Func<TResult> ToDelegate()
• public struct ValueFunc<T, TResult> : IValueDelegate<Func<T, TResult>>, ICallable<Func<T, TResult>>, ICallable, IConvertible<Func<T, TResult>>, ISupplier<Func<T, TResult>>, IValueDelegate<Converter<T, TResult>>, ICallable<Converter<T, TResult>>, IConvertible<Converter<T, TResult>>, ISupplier<Converter<T, TResult>>, IEquatable<ValueFunc<T, TResult>>
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueFunc(MethodInfo method)
  • public ValueFunc(Func<T, TResult> func, bool wrap = false)
  • public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
  • public static Func<T, TResult> op_Explicit(ref ValueFunc func)
  • public static Converter<T, TResult> op_Explicit(ref ValueFunc func)
  • public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
  • public bool Equals(ValueFunc<T, TResult> other)
  • public TResult Invoke(T arg)
  • public Func<T, TResult> ToDelegate()
• public struct ValueFunc<T1, T2, TResult> : IValueDelegate<Func<T1, T2, TResult>>, ICallable<Func<T1, T2, TResult>>, ICallable, IConvertible<Func<T1, T2, TResult>>, ISupplier<Func<T1, T2, TResult>>, IEquatable<ValueFunc<T1, T2, TResult>>, ISupplier<T1, T2, TResult>
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueFunc(MethodInfo method)
  • public ValueFunc(Func<T1, T2, TResult> func, bool wrap = false)
  • public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
  • public static Func<T1, T2, TResult> op_Explicit(ref ValueFunc pointer)
  • public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
  • public bool Equals(ValueFunc<T1, T2, TResult> other)
  • public TResult Invoke(T1 arg1, T2 arg2)
  • public Func<T1, T2, TResult> ToDelegate()
• public struct ValueFunc<T1, T2, T3, TResult> : IValueDelegate<Func<T1, T2, T3, TResult>>, ICallable<Func<T1, T2, T3, TResult>>, ICallable, IConvertible<Func<T1, T2, T3, TResult>>, ISupplier<Func<T1, T2, T3, TResult>>, IEquatable<ValueFunc<T1, T2, T3, TResult>>
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueFunc(MethodInfo method)
  • public ValueFunc(Func<T1, T2, T3, TResult> func, bool wrap = false)
  • public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
  • public static Func<T1, T2, T3, TResult> op_Explicit(ref ValueFunc pointer)
  • public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
  • public bool Equals(ValueFunc<T1, T2, T3, TResult> other)
  • public TResult Invoke(T1 arg1, T2 arg2, T3 arg3)
  • public Func<T1, T2, T3, TResult> ToDelegate()
• public struct ValueFunc<T1, T2, T3, T4, TResult> : IValueDelegate<Func<T1, T2, T3, T4, TResult>>, ICallable<Func<T1, T2, T3, T4, TResult>>, ICallable, IConvertible<Func<T1, T2, T3, T4, TResult>>, ISupplier<Func<T1, T2, T3, T4, TResult>>, IEquatable<ValueFunc<T1, T2, T3, T4, TResult>>
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueFunc(MethodInfo method)
  • public ValueFunc(Func<T1, T2, T3, T4, TResult> func, bool wrap = false)
  • public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
  • public static Func<T1, T2, T3, T4, TResult> op_Explicit(ref ValueFunc pointer)
  • public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
  • public bool Equals(ValueFunc<T1, T2, T3, T4, TResult> other)
  • public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
  • public Func<T1, T2, T3, T4, TResult> ToDelegate()
• public struct ValueFunc<T1, T2, T3, T4, T5, TResult> : IValueDelegate<Func<T1, T2, T3, T4, T5, TResult>>, ICallable<Func<T1, T2, T3, T4, T5, TResult>>, ICallable, IConvertible<Func<T1, T2, T3, T4, T5, TResult>>, ISupplier<Func<T1, T2, T3, T4, T5, TResult>>, IEquatable<ValueFunc<T1, T2, T3, T4, T5, TResult>>
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueFunc(MethodInfo method)
  • public ValueFunc(Func<T1, T2, T3, T4, T5, TResult> func, bool wrap = false)
  • public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
  • public static Func<T1, T2, T3, T4, T5, TResult> op_Explicit(ref ValueFunc pointer)
  • public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
  • public bool Equals(ValueFunc<T1, T2, T3, T4, T5, TResult> other)
  • public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
  • public Func<T1, T2, T3, T4, T5, TResult> ToDelegate()
• public struct ValueRefAction<T, TArgs> : IValueDelegate<RefAction<T, TArgs>>, ICallable<RefAction<T, TArgs>>, ICallable, IConvertible<RefAction<T, TArgs>>, ISupplier<RefAction<T, TArgs>>, IEquatable<ValueRefAction<T, TArgs>>
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueRefAction(MethodInfo method)
  • public ValueRefAction(RefAction<T, TArgs> action, bool wrap = false)
  • public ValueRefAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueRefAction first, ref ValueRefAction second)
  • public static RefAction<T, TArgs> op_Explicit(ref ValueRefAction pointer)
  • public static bool op_Inequality(ref ValueRefAction first, ref ValueRefAction second)
  • public bool Equals(ValueRefAction<T, TArgs> other)
  • public void Invoke(ref T reference, TArgs args)
  • public RefAction<T, TArgs> ToDelegate()
• public struct ValueRefFunc<T, TArgs, TResult> : IValueDelegate<RefFunc<T, TArgs, TResult>>, ICallable<RefFunc<T, TArgs, TResult>>, ICallable, IConvertible<RefFunc<T, TArgs, TResult>>, ISupplier<RefFunc<T, TArgs, TResult>>, IEquatable<ValueRefFunc<T, TArgs, TResult>>
  • public bool IsEmpty { get; }
  • public object Target { get; }
  • public ValueRefFunc(MethodInfo method)
  • public ValueRefFunc(RefFunc<T, TArgs, TResult> func, bool wrap = false)
  • public ValueRefFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
  • public static bool op_Equality(ref ValueRefFunc first, ref ValueRefFunc second)
  • public static RefFunc<T, TArgs, TResult> op_Explicit(ref ValueRefFunc pointer)
  • public static bool op_Inequality(ref ValueRefFunc first, ref ValueRefFunc second)
  • public bool Equals(ValueRefFunc<T, TArgs, TResult> other)
  • public TResult Invoke(ref T reference, TArgs args)
  • public RefFunc<T, TArgs, TResult> ToDelegate()
• public static class ValueTypeExtensions
  • public static float EnsureFinite(this float value)
  • public static double EnsureFinite(this double value)
  • public static IntPtr LeftShift(this IntPtr value, int bits)
  • public static UIntPtr LeftShift(this UIntPtr value, int bits)
  • public static IntPtr RightShift(this IntPtr value, int bits)
  • public static UIntPtr RightShift(this UIntPtr value, int bits)
  • public static IntPtr ToIntPtrChecked(this UIntPtr value)
  • public static UIntPtr ToUIntPtrChecked(this IntPtr value)

DotNext.Buffers

• public struct BufferConsumer<T> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IEquatable<BufferConsumer<T>>
• public static class BufferHelpers
• public abstract class BufferWriter<T> : Disposable, IBufferWriter<T>, ISupplier<ReadOnlyMemory<T>>, IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IGrowableBuffer<T>, IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IDisposable
• public struct BufferWriterSlim<T>
• public struct DelegatingReadOnlySpanConsumer<T, TArg> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>
• public interface IGrowableBuffer<T> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IDisposable
• public interface IReadOnlySpanConsumer<T> : ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>
• public struct ArrayRental<T> : IMemoryOwner<T>, IDisposable, IConvertible<Memory<T>>, IConvertible<ArraySegment<T>>, IConvertible<MemoryOwner<T>>
  • public bool IsEmpty { get; }
  • public ref T this[long index] { get; }
  • public int Length { get; }
  • public Memory<T> Memory { get; }
  • public MemoryOwner<T> Owner { get; }
  • public ArraySegment<T> Segment { get; }
  • public Span<T> Span { get; }
  • public ArrayRental(ArrayPool<T> pool, int minimumLength, bool clearArray)
  • public ArrayRental(ArrayPool<T> pool, int minimumLength)
  • public ArrayRental(int minimumLength, bool clearArray)
  • public ArrayRental(int minimumLength)
  • public ArrayRental(T[] array, int length)
  • public ArrayRental(T[] array)
  • public static MemoryOwner<T> op_Implicit(ref ArrayRental array)
  • public void Clear()
  • public void Dispose()
  • public ref T GetPinnableReference()
• public static class ChunkSequence
  • public static 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 struct ChunkSequence<T> : IEnumerable<ReadOnlyMemory<T>>, IEnumerable
  • public struct Enumerator<T> : IEnumerator<ReadOnlyMemory<T>>, IEnumerator, IDisposable
  • public ChunkSequence(ReadOnlyMemory<T> memory, int chunkSize)
  • public static ReadOnlySequence<T> op_Explicit(ChunkSequence<T> sequence)
  • public Enumerator<T> GetEnumerator()
  • public ReadOnlySequence<T> ToReadOnlySequence()
• public static class MemoryAllocator
  • public static MemoryAllocator<T> CreateArrayAllocator<T>()
  • public static MemoryOwner<T> Invoke<T>(this MemoryAllocator<T> allocator, int length, bool exactSize)
  • public static MemoryAllocator<T> ToAllocator<T>(this Func<int, IMemoryOwner<T>> provider)
• public struct MemoryOwner<T> : IMemoryOwner<T>, IDisposable, IConvertible<Memory<T>>
  • public ref T this[IntPtr index] { get; }
  • public MemoryOwner(Func<int, IMemoryOwner<T>> provider, int length)
  • public MemoryOwner(Func<IMemoryOwner<T>> provider)
  • public static MemoryOwner<T> Create<TArg>(method provider, int length, TArg arg, bool exactSize = true)
  • public bool TryGetArray(out ArraySegment segment)
  • public bool TryResize(int newLength)
• public struct MemoryRental<T>
  • public MemoryRental(MemoryPool<T> pool, int minBufferSize, bool exactSize = true)
  • public MemoryRental(MemoryPool<T> pool, int minBufferSize)
  • public MemoryRental(int minBufferSize, bool exactSize = true)
  • public MemoryRental(int minBufferSize)
• public static class MemoryTemplate
• public struct MemoryTemplate<T> where T : IEquatable<T>
• 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 ref T this[int index] { get; }
  • public ref T this[long index] { get; }
  • public PooledArrayBufferWriter(int initialCapacity)
  • public void Insert(int index, ReadOnlySpan<T> items)
  • public void Overwrite(int index, ReadOnlySpan<T> items)
  • public void RemoveFirst(int count)
  • public void RemoveLast(int count)
• public struct ReadOnlySpanConsumer<T, TArg> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>
• public struct SpanReader<T>
• public struct SpanWriter<T>
• public enum SparseBufferGrowth
• public class SparseBufferWriter<T> : Disposable, IEnumerable<ReadOnlyMemory<T>>, IEnumerable, IGrowableBuffer<T>, IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IDisposable, ISupplier<ReadOnlySequence<T>>, IBufferWriter<T>

DotNext.Collections.Generic

• public static class Collection
  • public static ReadOnlyCollectionView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyCollection<TInput> collection, ref ValueFunc converter)
• public static class Dictionary
  • public static ReadOnlyDictionaryView<TKey, TValue, TResult> ConvertValues<TKey, TValue, TResult>(this IReadOnlyDictionary<TKey, TValue> dictionary, ref ValueFunc mapper)
  • public static void ForEach<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, ref ValueAction action)
  • public static TValue GetOrAdd<TKey, TValue, TFactory>(this Dictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TValue> valueFactory) where TFactory : struct, ISupplier<TKey, TValue>
  • public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key, ref ValueFunc valueFactory)
  • public static TValue GetOrInvoke<TKey, TValue, TSupplier>(this IDictionary<TKey, TValue> dictionary, TKey key, TSupplier defaultValue) where TSupplier : struct, ISupplier<TValue>
  • public static TValue GetOrInvoke<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, ref ValueFunc defaultValue)
  • public static Func<IEnumerable<TKey>> KeysGetter<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary)
  • public static Func<ICollection<TKey>> KeysGetter<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
  • public static Func<IEnumerable<TValue>> ValuesGetter<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary)
  • public static Func<ICollection<TValue>> ValuesGetter<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
• public static class List
  • public static ReadOnlyListView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyList<TInput> list, ref ValueFunc converter)
  • public static int InsertOrdered<T, TComparer>(this IList<T> list, T item, TComparer comparer) where TComparer : IComparer<T>
  • public static int InsertOrdered<T>(this IList<T> list, T item, ref ValueFunc comparer)
  • public static int InsertOrdered<T>(this IList<T> list, T item, method comparer)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, ref ValueFunc mapper)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, method mapper)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, ref ValueFunc mapper)
  • public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, method mapper)
• public struct ReadOnlyCollectionView<TInput, TOutput> : IReadOnlyCollection<TOutput>, IEnumerable<TOutput>, IEnumerable, IEquatable<ReadOnlyCollectionView<TInput, TOutput>>
  • public ReadOnlyCollectionView(IReadOnlyCollection<TInput> collection, Func<TInput, TOutput> mapper)
  • public ReadOnlyCollectionView(IReadOnlyCollection<TInput> collection, Converter<TInput, TOutput> mapper)
  • public static bool op_Equality(ref ReadOnlyCollectionView first, ref ReadOnlyCollectionView second)
  • public static bool op_Inequality(ref ReadOnlyCollectionView first, ref ReadOnlyCollectionView second)
  • public ReadOnlyCollectionView(IReadOnlyCollection<TInput> collection, ref ValueFunc mapper)
  • public static bool op_Equality(ReadOnlyCollectionView<TInput, TOutput> first, ReadOnlyCollectionView<TInput, TOutput> second)
  • public static bool op_Inequality(ReadOnlyCollectionView<TInput, TOutput> first, ReadOnlyCollectionView<TInput, TOutput> second)
• public struct ReadOnlyDictionaryView<TKey, TInput, TOutput> : IReadOnlyDictionary<TKey, TOutput>, IEnumerable<KeyValuePair<TKey, TOutput>>, IEnumerable, IReadOnlyCollection<KeyValuePair<TKey, TOutput>>, IEquatable<ReadOnlyDictionaryView<TKey, TInput, TOutput>>
  • public ReadOnlyDictionaryView(IReadOnlyDictionary<TKey, TInput> dictionary, Func<TInput, TOutput> mapper)
  • public ReadOnlyDictionaryView(IReadOnlyDictionary<TKey, TInput> dictionary, Converter<TInput, TOutput> mapper)
  • public static bool op_Equality(ref ReadOnlyDictionaryView first, ref ReadOnlyDictionaryView second)
  • public static bool op_Inequality(ref ReadOnlyDictionaryView first, ref ReadOnlyDictionaryView second)
  • public ReadOnlyDictionaryView(IReadOnlyDictionary<TKey, TInput> dictionary, ref ValueFunc mapper)
  • public static bool op_Equality(ReadOnlyDictionaryView<TKey, TInput, TOutput> first, ReadOnlyDictionaryView<TKey, TInput, TOutput> second)
  • public static bool op_Inequality(ReadOnlyDictionaryView<TKey, TInput, TOutput> first, ReadOnlyDictionaryView<TKey, TInput, TOutput> second)
• public struct ReadOnlyListView<TInput, TOutput> : IReadOnlyList<TOutput>, IEnumerable<TOutput>, IEnumerable, IReadOnlyCollection<TOutput>, IEquatable<ReadOnlyListView<TInput, TOutput>>
  • public ReadOnlyListView(IReadOnlyList<TInput> list, Func<TInput, TOutput> mapper)
  • public ReadOnlyListView(IReadOnlyList<TInput> list, Converter<TInput, TOutput> mapper)
  • public static bool op_Equality(ref ReadOnlyListView first, ref ReadOnlyListView second)
  • public static bool op_Inequality(ref ReadOnlyListView first, ref ReadOnlyListView second)
  • public ReadOnlyListView(IReadOnlyList<TInput> list, ref ValueFunc mapper)
  • public static bool op_Equality(ReadOnlyListView<TInput, TOutput> first, ReadOnlyListView<TInput, TOutput> second)
  • public static bool op_Inequality(ReadOnlyListView<TInput, TOutput> first, ReadOnlyListView<TInput, TOutput> second)
• public static class Sequence
• public static class Stack
  • public static Stack<T> Clone<T>(this Stack<T> original)
  • public static bool TryPeek<T>(this Stack<T> stack, out T obj)
  • public static bool TryPop<T>(this Stack<T> stack, out T obj)

DotNext.Diagnostics

• public struct Timestamp : IEquatable<Timestamp>, IComparable<Timestamp>
  • public static Timestamp VolatileRead(ref Timestamp location)
  • public static void VolatileWrite(ref Timestamp location, Timestamp newValue)
• public sealed class UnreachableCodeExecutionException : Exception
  • public UnreachableCodeExecutionException()

DotNext.IO

• public interface IFlushable
  • void DiscoverFlushMethods<T>(T obj, ref Action flush, ref Func flushAsync)
• public struct StreamConsumer : IReadOnlySpanConsumer<byte>, ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>, IEquatable<StreamConsumer>, IFlushable
• public static class StreamSource
  • public static Stream AsAsynchronousStream<TOutput>(TOutput output) where TOutput : ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>, IFlushable
  • public static Stream AsStream(this ArraySegment<byte> segment, bool writable = false)
  • public static Stream AsStream<TArg>(this ReadOnlySpanAction<byte, TArg> writer, TArg arg, Action<TArg> flush = null, Func<TArg, CancellationToken, Task> flushAsync = null)
  • public static Stream AsStream(this SparseBufferWriter<byte> writer, bool readable)
  • public static Stream AsStream<TArg>(this Func<ReadOnlyMemory<byte>, TArg, CancellationToken, ValueTask> writer, TArg arg, Action<TArg> flush = null, Func<TArg, CancellationToken, Task> flushAsync = null)
  • public static Stream AsSynchronousStream<TOutput>(TOutput output) where TOutput : IFlushable, IReadOnlySpanConsumer<byte>
  • public static Stream GetWrittenBytesAsStream(this PooledArrayBufferWriter<byte> writer)
• public struct TextConsumer : IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFlushable

DotNext.Reflection

• public static class DisposableType
  • public static MethodInfo GetDisposeAsyncMethod(this Type type)
• public static class EnumType
• public static class MethodExtensions
  • public static Result<object> TryInvoke(this MethodBase method, object obj, object[] args)
• public static class TaskType
  • public static Type MakeTaskType(this Type taskResult, bool valueTask)

DotNext.Resources

• public struct ResourceEntry
• public static class ResourceManagerExtensions

DotNext.Runtime

• public struct Box<T> : IEquatable<Box<T>> where T : struct
• public static class Intrinsics
  • public static Exception Error(object obj)
  • public static T GetElement<T>(T[] array, IntPtr index)
  • public static T GetElement<T>(T[] array, UIntPtr index)
  • public static ref T GetElementReference<T>(T[] array, IntPtr index)
  • public static ref T GetElementReference<T>(T[] array, UIntPtr index)
  • public static int GetHashCode32<T>(Func<T, int, int> getter, int count, T arg, bool salted = true)
  • public static int GetHashCode32<THashFunction>(Void* source, long length, int hash, THashFunction hashFunction, bool salted = true) where THashFunction : struct, ISupplier<int, int, int>
  • public static int GetHashCode32(Void* source, long length, int hash, ref ValueFunc hashFunction, bool salted = true)
  • public static long GetHashCode64<T>(Func<T, int, long> getter, int count, T arg, bool salted = true)
  • public static long GetHashCode64<THashFunction>(Void* source, long length, long hash, THashFunction hashFunction, bool salted = true) where THashFunction : struct, ISupplier<long, long, long>
  • public static long GetHashCode64(Void* source, long length, long hash, ref ValueFunc hashFunction, bool salted = true)
  • public static IntPtr GetLength(Array array)
  • public static TBase& modreq(System.Runtime.InteropServices.InAttribute) GetReadonlyRef<T, TBase>(this T[] array, IntPtr index) where T : TBase
  • public static 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 IsNull<T>(ref T value)
  • public static int PointerHashCode(Void* pointer)
  • public static T ShallowCopy<T>(T obj)
  • public static void Throw(object obj)
  • public static int ToInt32(bool low, bool high)

DotNext.Runtime.CompilerServices

• public sealed class CallerMustBeSynchronizedAttribute : Attribute
• public sealed class FunctionalInterfaceAttribute : Attribute
• public abstract class AsyncDelegateFuture : Future<Task>, IAwaiter, IFuture, INotifyCompletion
  • public IAwaiter GetAwaiter()
• public struct Box<T> : IEquatable<Box<T>> where T : struct
  • public bool IsEmpty { get; }
  • public ref T Value { get; }
  • public Box(object boxed)
  • public Box(T value)
  • public static bool op_Equality(Box<T> x, Box<T> y)
  • public static T op_Explicit(Box<T> box)
  • public static bool op_Inequality(Box<T> x, Box<T> y)
  • public bool Equals(Box<T> other)
• public struct ManagedMethodPointer : IEquatable<ManagedMethodPointer>
  • public static bool op_Equality(ManagedMethodPointer x, ManagedMethodPointer y)
  • public static bool op_Inequality(ManagedMethodPointer x, ManagedMethodPointer y)
  • public bool Equals(ManagedMethodPointer other)
• public sealed class RuntimeFeaturesAttribute : Attribute
  • public bool DynamicCodeCompilation { get; set; }
  • public bool PrivateReflection { get; set; }
  • public bool RuntimeGenericInstantiation { get; set; }
  • public bool Augmentation
  • public bool DynamicCodeCompilation
  • public bool PrivateReflection
  • public bool RuntimeGenericInstantiation

DotNext.Runtime.InteropServices

• public static class SafeBufferExtensions

DotNext.Security.Cryptography

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

DotNext.Text

• public struct Base64Decoder
• public static class EncodingExtensions
  • public static MemoryOwner<byte> GetBytes(this Encoding encoding, ReadOnlySpan<char> chars, MemoryAllocator<byte> allocator = null)
  • public static MemoryOwner<char> GetChars(this Encoding encoding, ReadOnlySpan<byte> bytes, MemoryAllocator<char> allocator = null)

DotNext.Threading

• public static class AsyncDelegate
  • public static Task BeginInvoke(this Action<object> action, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null)
  • public static Task BeginInvoke(this Action<object, CancellationToken> action, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null, CancellationToken token = default)
  • public static Task<TResult> BeginInvoke<TResult>(this Func<object, TResult> function, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null)
  • public static Task<TResult> BeginInvoke<TResult>(this Func<object, CancellationToken, TResult> function, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null, CancellationToken token = default)
  • public static Task InvokeAsync<TDelegate>(this TDelegate delegate, Action<TDelegate> invoker, CancellationToken token = default) where TDelegate : MulticastDelegate
  • public static Task InvokeAsync<TEventArgs>(this EventHandler<TEventArgs> handler, object sender, TEventArgs args, CancellationToken token = default)
  • public 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 static AsyncDelegateFuture InvokeAsync<TDelegate>(this TDelegate delegate, Action<TDelegate> invoker, CancellationToken token = default) where TDelegate : MulticastDelegate
  • public static AsyncDelegateFuture InvokeAsync<TEventArgs>(this EventHandler<TEventArgs> handler, object sender, TEventArgs args, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync(this EventHandler handler, object sender, EventArgs args, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync(this Action action, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T>(this Action<T> action, T arg, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2>(this Action<T1, T2> action, T1 arg1, T2 arg2, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3>(this Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6>(this Action<T1, T2, T3, T4, T5, T6> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6, T7>(this Action<T1, T2, T3, T4, T5, T6, T7> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Action<T1, T2, T3, T4, T5, T6, T7, T8> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, CancellationToken token = default)
  • public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, CancellationToken token = default)
• public struct Atomic<T> : IStrongBox, ICloneable where T : struct
  • public bool CompareAndSet(Func<T, T, bool> comparer, ref T expected, ref T update)
  • public bool CompareAndSet(method comparer, ref T expected, ref T update)
  • public bool CompareExchange(Func<T, T, bool> comparer, ref T update, ref T expected, out T result)
  • public bool CompareExchange(method comparer, ref T update, ref T expected, out T result)
• public struct AtomicBoolean : IEquatable<bool>, ISerializable
  • public bool AccumulateAndGet(bool x, method accumulator)
  • public bool AccumulateAndGet(bool x, ref ValueFunc accumulator)
  • public bool GetAndAccumulate(bool x, method accumulator)
  • public bool GetAndAccumulate(bool x, ref ValueFunc accumulator)
  • public bool GetAndUpdate(method updater)
  • public bool GetAndUpdate(ref ValueFunc updater)
  • public bool UpdateAndGet(method updater)
  • public bool UpdateAndGet(ref ValueFunc updater)
• public static class AtomicDouble
  • public static double AccumulateAndGet(this ref double value, double x, method accumulator)
  • public static double AccumulateAndGet(this ref double value, double x, ref ValueFunc accumulator)
  • public static double AccumulateAndGet(this double[] array, long index, double x, method accumulator)
  • public static double AccumulateAndGet(this double[] array, long index, double x, ref ValueFunc accumulator)
  • public static double GetAndAccumulate(this ref double value, double x, method accumulator)
  • public static double GetAndAccumulate(this ref double value, double x, ref ValueFunc accumulator)
  • public static double GetAndAccumulate(this double[] array, long index, double x, method accumulator)
  • public static double GetAndAccumulate(this double[] array, long index, double x, ref ValueFunc accumulator)
  • public static double GetAndUpdate(this ref double value, method updater)
  • public static double GetAndUpdate(this ref double value, ref ValueFunc updater)
  • public static double GetAndUpdate(this double[] array, long index, method updater)
  • public static double GetAndUpdate(this double[] array, long index, ref ValueFunc updater)
  • public static double UpdateAndGet(this ref double value, method updater)
  • public static double UpdateAndGet(this ref double value, ref ValueFunc updater)
  • public static double UpdateAndGet(this double[] array, long index, method updater)
  • public static double UpdateAndGet(this double[] array, long index, ref ValueFunc updater)
• public struct AtomicEnum<TEnum> : IEquatable<TEnum>, ISerializable where TEnum : struct, Enum
  • public TEnum AccumulateAndGet(TEnum x, method accumulator)
  • public TEnum AccumulateAndGet(TEnum x, ref ValueFunc accumulator)
  • public TEnum GetAndAccumulate(TEnum x, method accumulator)
  • public TEnum GetAndAccumulate(TEnum x, ref ValueFunc accumulator)
  • public TEnum GetAndUpdate(method updater)
  • public TEnum GetAndUpdate(ref ValueFunc updater)
  • public TEnum UpdateAndGet(method updater)
  • public TEnum UpdateAndGet(ref ValueFunc updater)
• public static class AtomicInt32
  • public static int AccumulateAndGet(this ref int value, int x, method accumulator)
  • public static int AccumulateAndGet(this ref int value, int x, ref ValueFunc accumulator)
  • public static int AccumulateAndGet(this int[] array, long index, int x, method 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, method 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, method accumulator)
  • public static int GetAndAccumulate(this int[] array, long index, int x, ref ValueFunc accumulator)
  • public static int GetAndUpdate(this ref int value, method updater)
  • public static int GetAndUpdate(this ref int value, ref ValueFunc updater)
  • public static int GetAndUpdate(this int[] array, long index, method updater)
  • public static int GetAndUpdate(this int[] array, long index, ref ValueFunc updater)
  • public static int UpdateAndGet(this ref int value, method updater)
  • public static int UpdateAndGet(this ref int value, ref ValueFunc updater)
  • public static int UpdateAndGet(this int[] array, long index, method 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, method accumulator)
  • public static long AccumulateAndGet(this ref long value, long x, ref ValueFunc accumulator)
  • public static long AccumulateAndGet(this long[] array, long index, long x, method 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, method 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, method accumulator)
  • public static long GetAndAccumulate(this long[] array, long index, long x, ref ValueFunc accumulator)
  • public static long GetAndUpdate(this ref long value, method updater)
  • public static long GetAndUpdate(this ref long value, ref ValueFunc updater)
  • public static long GetAndUpdate(this long[] array, long index, method updater)
  • public static long GetAndUpdate(this long[] array, long index, ref ValueFunc updater)
  • public static long UpdateAndGet(this ref long value, method updater)
  • public static long UpdateAndGet(this ref long value, ref ValueFunc updater)
  • public static long UpdateAndGet(this long[] array, long index, method updater)
  • public static long UpdateAndGet(this long[] array, long index, ref ValueFunc updater)
• public static class AtomicIntPtr
  • public static IntPtr AccumulateAndGet(this ref IntPtr value, IntPtr x, method accumulator)
  • public static IntPtr AccumulateAndGet(this ref IntPtr value, IntPtr x, ref ValueFunc accumulator)
  • public static IntPtr AccumulateAndGet(this IntPtr[] array, long index, IntPtr x, method accumulator)
  • public static IntPtr AccumulateAndGet(this IntPtr[] array, long index, IntPtr x, ref ValueFunc accumulator)
  • public static IntPtr GetAndAccumulate(this ref IntPtr value, IntPtr x, method accumulator)
  • public static IntPtr GetAndAccumulate(this ref IntPtr value, IntPtr x, ref ValueFunc accumulator)
  • public static IntPtr GetAndAccumulate(this IntPtr[] array, long index, IntPtr x, method accumulator)
  • public static IntPtr GetAndAccumulate(this IntPtr[] array, long index, IntPtr x, ref ValueFunc accumulator)
  • public static IntPtr GetAndUpdate(this ref IntPtr value, method updater)
  • public static IntPtr GetAndUpdate(this ref IntPtr value, ref ValueFunc updater)
  • public static IntPtr GetAndUpdate(this IntPtr[] array, long index, method updater)
  • public static IntPtr GetAndUpdate(this IntPtr[] array, long index, ref ValueFunc updater)
  • public static IntPtr UpdateAndGet(this ref IntPtr value, method updater)
  • public static IntPtr UpdateAndGet(this ref IntPtr value, ref ValueFunc updater)
  • public static IntPtr UpdateAndGet(this IntPtr[] array, long index, method updater)
  • public static IntPtr UpdateAndGet(this IntPtr[] array, long index, ref ValueFunc updater)
• public static class AtomicReference
  • public static T AccumulateAndGet<T>(ref T value, T x, method accumulator)
  • public static T AccumulateAndGet<T>(ref T value, T x, ref ValueFunc accumulator)
  • public static T AccumulateAndGet<T>(this T[] array, long index, T x, method 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, method 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, method accumulator)
  • public static T GetAndAccumulate<T>(this T[] array, long index, T x, ref ValueFunc accumulator)
  • public static T GetAndUpdate<T>(ref T value, method updater)
  • public static T GetAndUpdate<T>(ref T value, ref ValueFunc updater)
  • public static T GetAndUpdate<T>(this T[] array, long index, method updater)
  • public static T GetAndUpdate<T>(this T[] array, long index, ref ValueFunc updater)
  • public static T UpdateAndGet<T>(ref T value, method updater)
  • public static T UpdateAndGet<T>(ref T value, ref ValueFunc updater)
  • public static T UpdateAndGet<T>(this T[] array, long index, method updater)
  • public static T UpdateAndGet<T>(this T[] array, long index, ref ValueFunc updater)
• public struct AtomicReference<T> : IEquatable<T>, ISerializable
  • public T Value { get; set; }
  • public AtomicReference(T value)
  • public T AccumulateAndGet(T x, Func<T, T, T> accumulator)
  • public T AccumulateAndGet(T x, ref ValueFunc accumulator)
  • public bool CompareAndSet(T expected, T update)
  • public T CompareExchange(T expected, T update)
  • public bool Equals(T other)
  • public T GetAndAccumulate(T x, Func<T, T, T> accumulator)
  • public T GetAndAccumulate(T x, ref ValueFunc accumulator)
  • public T GetAndSet(T update)
  • public T GetAndUpdate(Func<T, T> updater)
  • public T GetAndUpdate(ref ValueFunc updater)
  • public T SetAndGet(T update)
  • public T SetIfNull<TDerived>() where TDerived : T
  • public T SetIfNull(Func<T> supplier)
  • public T UpdateAndGet(Func<T, T> updater)
  • public T UpdateAndGet(ref ValueFunc updater)
• public static class AtomicSingle
  • public static float AccumulateAndGet(this ref float value, float x, method accumulator)
  • public static float AccumulateAndGet(this ref float value, float x, ref ValueFunc accumulator)
  • public static float AccumulateAndGet(this float[] array, long index, float x, method 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, method 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, method accumulator)
  • public static float GetAndAccumulate(this float[] array, long index, float x, ref ValueFunc accumulator)
  • public static float GetAndUpdate(this ref float value, method updater)
  • public static float GetAndUpdate(this ref float value, ref ValueFunc updater)
  • public static float GetAndUpdate(this float[] array, long index, method updater)
  • public static float GetAndUpdate(this float[] array, long index, ref ValueFunc updater)
  • public static float UpdateAndGet(this ref float value, method updater)
  • public static float UpdateAndGet(this ref float value, ref ValueFunc updater)
  • public static float UpdateAndGet(this float[] array, long index, method updater)
  • public static float UpdateAndGet(this float[] array, long index, ref ValueFunc updater)
• public struct Lock : IDisposable, IEquatable<Lock>
  • public static Lock Monitor(object obj, bool useSpinWait = false)
  • public static Lock Monitor(object obj)

DotNext.Threading.Tasks

• public static class Continuation
  • public static Task<T> ContinueWithTimeout<T>(this Task<T> task, TimeSpan timeout, CancellationToken token = default)
  • public static Task<T> OnFaulted<T, TConstant>(this Task<T> task, Predicate<AggregateException> filter, TaskScheduler scheduler = null) where TConstant : Constant<T>
  • public static Task<T> OnFaultedOrCanceled<T, TConstant>(this Task<T> task, Predicate<AggregateException> filter, TaskScheduler scheduler = null) where TConstant : Constant<T>
• public abstract class Future : IFuture, INotifyCompletion
  • public interface IAwaiter : IFuture, INotifyCompletion
  • public interface IAwaiter<TResult> : IFuture, INotifyCompletion
  • protected sealed class IncompletedFutureException : InvalidOperationException
  • public abstract bool IsCompleted { get; }
  • protected Future(bool runContinuationsAsynchronously = true)
  • protected void Complete()
  • public void OnCompleted(Action callback)
• public abstract class Future<T> : Future, IConvertible<T> where T : Task
  • protected Future(bool runContinuationsAsynchronously = true)
  • public abstract T AsTask()

DotNext.VariantType

• public struct Variant<T1, T2> : IEquatable<Variant<T1, T2>>, IVariant, IDynamicMetaObjectProvider
  • public Optional<TResult> Convert<TResult>(ref ValueFunc mapper1, ref ValueFunc mapper2)
  • public Optional<TResult> Convert<TResult>(method mapper1, method mapper2)
  • public Variant<TResult1, TResult2> Convert<TResult1, TResult2>(ref ValueFunc mapper1, ref ValueFunc mapper2)
  • public Variant<TResult1, TResult2> Convert<TResult1, TResult2>(method mapper1, method mapper2)