DotNext by Roman Sakno

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

---

API Diff between 0.12.0 and 2.2.0

126 Additions 145 Removals

DotNext

• public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : struct
  • public static int Compare<G>(ref T first, ref G second) where G : struct
  • public static bool Equals<G>(ref T first, ref G second) where G : struct
  • public static int GetHashCode(ref T value, bool salted = true)
  • public static int GetHashCode(ref T value, int hash, ref ValueFunc hashFunction, bool salted)
  • public static int GetHashCode(ref T value, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int Compare<G>(T first, G second) where G : struct
  • public static bool Equals<G>(T first, G second) where G : struct
  • public static int GetHashCode(T value, bool salted = true)
  • public static int GetHashCode(T value, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode(T value, int hash, ref ValueFunc hashFunction, bool salted = true)
• public static 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 T Max<T>(T first, T second, Comparison<T> comparer)
  • public static T Max<T>(T first, T second, IComparer<T> comparer)
  • public static T Max<T>(this T first, T second) where T : IComparable<T>
  • public static T Min<T>(T first, T second, Comparison<T> comparer)
  • public static T Min<T>(T first, T second, IComparer<T> comparer)
  • public static T Min<T>(this T first, T second) where T : IComparable<T>
• public static class Comparison
  • public static bool Between<T>(this T value, T left, T right, BoundType boundType = 0) where T : IComparable<T>
  • public static T Clamp<T>(this T value, T min, T max) where T : IComparable<T>
• public abstract class Disposable : IDisposable
  • public static ValueTask DisposeAsync(IEnumerable<IAsyncDisposable> objects)
  • public static ValueTask DisposeAsync(IAsyncDisposable[] objects)
• public struct Enum<E> : IEquatable<E>, IComparable<E>, IFormattable, IEquatable<Enum<E>>, ISerializable where E : struct, Enum
  • public bool IsFlag(E flags)
• public struct EnumerableTuple<I, T> : IReadOnlyList<I>, IEnumerable<I>, IEnumerable, IReadOnlyCollection<I> where T : IStructuralEquatable, IStructuralComparable
  • public int CopyTo(Span<I> output)
• public interface IConvertible<T>
• public static class OneDimensionalArray
  • public static T[] Concat<T>(this T[] left, T[] right, long startIndex)
  • public static bool SequenceEqual(this object[] first, object[] second, bool parallel = false)
  • public static bool SequenceEqual(this object[] first, object[] second)
  • public static ArraySegment<T> Slice<T>(this T[] input, ref Range range)
• public struct Optional<T> : IEquatable<Optional<T>>, IEquatable<T>, IStructuralEquatable, ISerializable
  • public bool HasValue { get; }
  • public bool IsPresent { get; }
  • public Optional<object> Box()
  • public bool Equals(Optional<T> other)
  • public bool Equals(ref Optional other)
• public static class RandomExtensions
  • public static T Next<T>(this Random random) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static T Next<T>(this RandomNumberGenerator random) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public sealed delegate RefFunc<T, TArgs, TResult> : MulticastDelegate
• public struct Result<T> : ISerializable
  • public Result<object> Box()
• public static class Sequence
  • public struct LimitedEnumerator<T> : IEnumerator<T>, IEnumerator, IDisposable
  • public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq, ref ValueFunc filter)
  • public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq, Predicate<T> filter)
  • public static LimitedEnumerator<T> Limit<T>(this IEnumerator<T> enumerator, int count, bool leaveOpen = false)
  • public static bool Skip<TEnumerator, T>(this ref TEnumerator enumerator, int count) where TEnumerator : struct, IEnumerator<T>
• public static class Span
  • public static Span<byte> AsBytes<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static Span<byte> AsBytes<T>(T* pointer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static ReadOnlySpan<byte> AsReadOnlyBytes<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void ForEach<T>(this Span<T> span, ref ValueRefAction action)
  • public static void ForEach<T>(this Span<T> span, RefAction<T, int> action)
  • public static int FromHex(this ReadOnlySpan<char> chars, Span<byte> output)
  • public static byte[] FromHex(this ReadOnlySpan<char> chars)
  • public static int IndexOf<T>(this ReadOnlySpan<T> span, T value, int startIndex, ref ValueFunc comparer)
  • public static int IndexOf<T>(this ReadOnlySpan<T> span, T value, int startIndex, Func<T, T, bool> comparer)
  • public static T Read<T>(ref ReadOnlySpan bytes) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int ToHex(this ReadOnlySpan<byte> bytes, Span<char> output, bool lowercased = false)
  • public static string ToHex(this ReadOnlySpan<byte> bytes, bool lowercased = false)
• public static class StringExtensions
  • public static string Substring(this string str, Range range)
• public struct UserDataStorage
  • public interface IContainer
  • public void CopyTo(object obj)
  • public V Get<V>(UserDataSlot<V> slot)
• public struct ValueAction : ICallable<Action>, ICallable, IEquatable<ValueAction>
  • public bool IsEmpty { get; }
  • public bool Equals(ValueAction other)
  • public bool Equals(ref ValueAction other)
• public struct ValueAction<T> : ICallable<Action<T>>, ICallable, IEquatable<ValueAction<T>>, IConsumer<T>
  • public bool IsEmpty { get; }
  • public bool Equals(ValueAction<T> other)
  • public bool Equals(ref ValueAction other)
• public struct ValueAction<T1, T2> : ICallable<Action<T1, T2>>, ICallable, IEquatable<ValueAction<T1, T2>>
  • public bool IsEmpty { get; }
  • public bool Equals(ValueAction<T1, T2> other)
  • public bool Equals(ref ValueAction other)
• public struct ValueAction<T1, T2, T3> : ICallable<Action<T1, T2, T3>>, ICallable, IEquatable<ValueAction<T1, T2, T3>>
  • public bool IsEmpty { get; }
  • public bool Equals(ValueAction<T1, T2, T3> other)
  • public bool Equals(ref ValueAction other)
• public struct ValueAction<T1, T2, T3, T4> : ICallable<Action<T1, T2, T3, T4>>, ICallable, IEquatable<ValueAction<T1, T2, T3, T4>>
  • public bool IsEmpty { get; }
  • public bool Equals(ValueAction<T1, T2, T3, T4> other)
  • public bool Equals(ref ValueAction other)
• public struct ValueAction<T1, T2, T3, T4, T5> : ICallable<Action<T1, T2, T3, T4, T5>>, ICallable, IEquatable<ValueAction<T1, T2, T3, T4, T5>>
  • public bool IsEmpty { get; }
  • public bool Equals(ValueAction<T1, T2, T3, T4, T5> other)
  • public bool Equals(ref ValueAction other)
• public struct ValueFunc<R> : ICallable<Func<R>>, ICallable, IEquatable<ValueFunc<R>>, ISupplier<R>
  • public bool IsEmpty { get; }
  • public bool Equals(ValueFunc<R> other)
  • public bool Equals(ref ValueFunc other)
• public struct ValueFunc<T, R> : ICallable<Func<T, R>>, ICallable, ICallable<Converter<T, R>>, IEquatable<ValueFunc<T, R>>
  • public bool IsEmpty { get; }
  • public bool Equals(ValueFunc<T, R> other)
  • public bool Equals(ref ValueFunc other)
• public struct ValueFunc<T1, T2, R> : ICallable<Func<T1, T2, R>>, ICallable, IEquatable<ValueFunc<T1, T2, R>>, ISupplier<T1, T2, R>
  • public bool IsEmpty { get; }
  • public bool Equals(ValueFunc<T1, T2, R> other)
  • public bool Equals(ref ValueFunc other)
• public struct ValueFunc<T1, T2, T3, R> : ICallable<Func<T1, T2, T3, R>>, ICallable, IEquatable<ValueFunc<T1, T2, T3, R>>
  • public bool IsEmpty { get; }
  • public bool Equals(ValueFunc<T1, T2, T3, R> other)
  • public bool Equals(ref ValueFunc other)
• public struct ValueFunc<T1, T2, T3, T4, R> : ICallable<Func<T1, T2, T3, T4, R>>, ICallable, IEquatable<ValueFunc<T1, T2, T3, T4, R>>
  • public bool IsEmpty { get; }
  • public bool Equals(ValueFunc<T1, T2, T3, T4, R> other)
  • public bool Equals(ref ValueFunc other)
• 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 bool IsEmpty { get; }
  • public bool Equals(ValueFunc<T1, T2, T3, T4, T5, R> other)
  • public bool Equals(ref ValueFunc other)
• public struct ValueRefAction<T, TArgs> : ICallable<RefAction<T, TArgs>>, ICallable, IEquatable<ValueRefAction<T, TArgs>>
  • public bool IsEmpty { get; }
  • public static bool op_Equality(ref ValueRefAction first, ref ValueRefAction second)
  • public static bool op_Equality(ref ValueRefAction first, ref ValueAction second)
  • public static bool op_Inequality(ref ValueRefAction first, ref ValueRefAction second)
  • public bool Equals(ValueRefAction<T, TArgs> other)
  • public static bool op_Inequality(ref ValueRefAction first, ref ValueAction second)
  • public bool Equals(ref ValueRefAction other)
• public struct ValueRefFunc<T, TArgs, TResult> : IValueDelegate<RefFunc<T, TArgs, TResult>>, ICallable<RefFunc<T, TArgs, TResult>>, ICallable, IConvertible<RefFunc<T, TArgs, TResult>>, ISupplier<RefFunc<T, TArgs, TResult>>, IEquatable<ValueRefFunc<T, TArgs, TResult>>
• public static class ValueTypeExtensions
  • public static float EnsureFinite(this float value)
  • public static double EnsureFinite(this double value)
  • public static IntPtr Remainder(this IntPtr x, IntPtr y)
  • public static UIntPtr Remainder(this UIntPtr x, UIntPtr y)
  • public static int Truncate(this long value)
  • public static bool TryGetValue<T>(this T? nullable, out T value) where T : struct
  • public static bool TryGet<T>(this T? nullable, out T value) where T : struct

DotNext.Buffers

• public struct ArrayRental<T> : IDisposable
  • public bool IsEmpty { get; }
  • public ref T this[long index] { get; }
  • public int Length { get; }
  • public ArraySegment<T> Segment { get; }
  • public Span<T> Span { get; }
  • public ArrayRental(T[] array, int length)
  • public ArrayRental(T[] array)
  • public void Clear()
  • public static T[] op_Implicit(ref ArrayRental rental)
  • 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 static Task CopyToAsync(this ChunkSequence<byte> sequence, Stream output, CancellationToken token = default)
  • public static Task CopyToAsync(this ChunkSequence<char> sequence, TextWriter output, CancellationToken token = default)
• public struct MemoryRental<T>

DotNext.Collections.Concurrent

• public class CopyOnWriteList<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IList<T>, ICollection<T>, ICloneable
  • public long Count { get; }
  • public T this[long index] { get; set; }
  • public CopyOnWriteList(IReadOnlyCollection<T> collection)
  • public CopyOnWriteList()
  • public static ReadOnlySpan<T> op_Explicit(CopyOnWriteList<T> list)
  • public void Add(T item)
  • public void Clear()
  • public void Clear(ref ValueAction cleaner)
  • public void Clear(Action<T> cleaner)
  • public CopyOnWriteList<T> Clone()
  • public bool Contains(T item)
  • public void CopyTo(T[] array, int arrayIndex)
  • public bool Exists(Predicate<T> match)
  • public T Find(Predicate<T> match)
  • public int FindIndex(Predicate<T> match)
  • public T FindLast(Predicate<T> match)
  • public int FindLastIndex(Predicate<T> match)
  • public Enumerator<T> GetEnumerator()
  • public int IndexOf(T item)
  • public void Insert(long index, T item)
  • public int LastIndexOf(T item)
  • public bool Remove(T item)
  • public long RemoveAll(ValueFunc<T, bool> match)
  • public long RemoveAll(Predicate<T> match)
  • public void RemoveAll(ref ValueFunc match, ref ValueAction callback)
  • public void RemoveAll(Predicate<T> match, Action<T> callback)
  • public void RemoveAt(long index)
  • 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 Dictionary
  • public static void Deconstruct<K, V>(this KeyValuePair<K, V> pair, out K key, out V value)
• public static class List
  • public static void Insert<T>(this IList<T> list, Index index, T item)
  • public static int InsertOrdered<T>(this IList<T> list, T item, Comparison<T> comparer)
  • public static void RemoveAt<T>(this IList<T> list, Index index)
  • public static void RemoveRange<T>(this List<T> list, Range range)
  • public static ListSegment<T> Slice<T>(this IList<T> list, Range range)
• public struct ListSegment<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyList<T>, IReadOnlyCollection<T>

DotNext.Diagnostics

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

DotNext.Generic

• public abstract class Int32Const : Constant<int>
• public abstract class Int64Const : Constant<long>
• public abstract class IntConst : Constant<int>
  • public sealed class Max : IntConst
  • public sealed class Min : IntConst
  • public sealed class Zero : IntConst
  • protected IntConst(int value)
• public abstract class LongConst : Constant<long>
  • public sealed class Max : LongConst
  • public sealed class Min : LongConst
  • public sealed class Zero : LongConst
  • protected LongConst(long value)

DotNext.IO

• public interface IFlushable

DotNext.Reflection

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

DotNext.Runtime

• public static class Intrinsics
  • public static IntPtr AddressOf<T>(ref T value)
  • public static bool AreSame<T>(ref T first, ref T second)
  • public static ref T AsRef<T>(TypedReference reference)
  • public static void ClearBits(Void* address, long length)
  • public static int Compare(Void* first, Void* second, long length)
  • public static void Copy<T>(ref T input, out T output) where T : struct
  • public static void Copy<T>(T* input, T* output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Copy<T>(ref T source, ref T destination, long count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void CopyUnaligned<T>(T* input, T* output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static bool Equals(Void* first, Void* second, long length)
  • public static int GetHashCode32(Void* source, long length, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode32(Void* source, long length, int hash, ref ValueFunc hashFunction, bool salted = true)
  • public static int GetHashCode32(Void* source, long length, bool salted = true)
  • public static long GetHashCode64(Void* source, long length, long hash, Func<long, long, long> hashFunction, bool salted = true)
  • public static long GetHashCode64(Void* source, long length, long hash, ref ValueFunc hashFunction, bool salted = true)
  • public static long GetHashCode64(Void* source, long length, bool salted = true)
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReadonlyRef<T>(T[] array, long index)
  • public static O& modreq(System.Runtime.InteropServices.InAttribute) GetReadonlyRef<I, O>(I[] array, long index) where I : O
  • public static bool HasFlag<T>(T value, T flag) where T : struct, Enum
  • public static bool IsDefault<T>(ref T value)
  • public static bool IsNull<T>(ref T value)
  • public static bool IsDefault<T>(T value)
  • public static void Reverse<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Swap<T>(ref T first, ref T second)
  • public static void Swap<T>(T* first, T* second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void ThrowIfNull<T>(ref T value)
  • public static RuntimeTypeHandle TypeOf<T>()

DotNext.Runtime.InteropServices

• public static class Memory
  • public static readonly Void* NullPtr
  • public static IntPtr AddressOf<T>(ref T value)
  • public static bool AreSame<T>(ref T first, ref T second)
  • public static ref T AsRef<T>(this TypedReference reference)
  • public static Span<byte> AsSpan<T>(T* pointer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void ClearBits(IntPtr address, long length)
  • public static void ClearBits(Void* address, long length)
  • public static int Compare(IntPtr first, IntPtr second, long length)
  • public static int Compare(Void* first, Void* second, long length)
  • public static void Copy(Void* source, Void* destination, long length)
  • public static void Copy(IntPtr source, IntPtr destination, long length)
  • public static void Copy<T>(ref T input, out T output) where T : struct
  • public static bool Equals(Void* first, Void* second, long length)
  • public static bool Equals(IntPtr first, IntPtr second, long length)
  • public static ref T GetBoxedValue<T>(object box) where T : struct
  • 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 bool IsNull<T>(ref T value)
  • public static T Read<T>(ref IntPtr source) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static T ReadUnaligned<T>(ref IntPtr source) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Swap<T>(ref T first, ref T second)
  • public static void Swap<T>(T* first, T* second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void ThrowIfNull<T>(ref T value)
  • public static T* ToPointer<T>(this IntPtr source) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Write<T>(ref IntPtr destination, T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void WriteUnaligned<T>(ref IntPtr destination, T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)

DotNext.Security.Cryptography

• public struct HashBuilder : ICryptoTransform, IDisposable

DotNext.Threading

• public struct Atomic<T> : IStrongBox, ICloneable where T : struct
  • public Atomic<T> Clone()
  • public void Clone(out Atomic container)
  • public bool CompareExchange(ref T update, ref T expected, out T result)
  • public void CompareExchange(ref T update, ref T expected, out T result)
• public struct ReaderWriterSpinLock
• public struct Timeout
  • public bool IsInfinite { get; }
  • public TimeSpan? RemainingTime { get; }
  • public void ThrowIfExpired(out TimeSpan remaining)

DotNext.Threading.Tasks

• public static class Conversion
  • public static DynamicTaskAwaitable AsDynamic(this Task task)
• public struct DynamicTaskAwaitable
• public abstract class Future : IFuture, INotifyCompletion
  • protected Future(bool runContinuationsAsynchronously = true)
  • protected Future()
• public abstract class Future<T> : Future where T : Task
  • protected Future(bool runContinuationsAsynchronously = true)
  • protected Future()
• public static class Synchronization
  • public static Result<object> GetResult(this Task task, CancellationToken token)
  • public static Result<object> GetResult(this Task task, TimeSpan timeout)

DotNext.VariantType

• public struct Variant<T1, T2> : IEquatable<Variant<T1, T2>>, IVariant, IDynamicMetaObjectProvider
  • 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, IEquatable<Variant<T1, T2, T3>>
  • public void Deconstruct(out T1 value1, out T2 value2, out T3 value3)
• public struct Variant<T1, T2, T3, T4> : IVariant, IDynamicMetaObjectProvider, IEquatable<Variant<T1, T2, T3, T4>>
  • public void Deconstruct(out T1 value1, out T2 value2, out T3 value3, out T4 value4)