DotNext by Roman Sakno

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

---

API Diff between 1.2.9 and 0.12.0

153 Additions 24 Removals

DotNext

• public struct Enum<E> : IEquatable<E>, IComparable<E>, IFormattable, IEquatable<Enum<E>>, ISerializable where E : struct, Enum
  • public bool HasFlag(E flag)
• public interface ICallable
  • bool IsEmpty { get; }
• public struct Optional<T> : IEquatable<Optional<T>>, IEquatable<T>, IStructuralEquatable, ISerializable
  • public bool Equals(ref Optional other)
  • public bool Equals(Optional<T> other)
• public sealed delegate RefFunc<T, TArgs, TResult> : MulticastDelegate
  • public RefFunc(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ref T reference, TArgs args, AsyncCallback callback, object object)
  • public virtual TResult EndInvoke(ref T reference, IAsyncResult result)
  • public virtual TResult Invoke(ref T reference, TArgs args)
• public static class Span
  • 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 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 struct ValueAction : ICallable<Action>, ICallable, IEquatable<ValueAction>
  • public bool IsEmpty { get; }
  • public bool Equals(ref ValueAction other)
  • public bool Equals(ValueAction other)
• public struct ValueAction<T> : ICallable<Action<T>>, ICallable, IEquatable<ValueAction<T>>, IConsumer<T>
  • public bool IsEmpty { get; }
  • public bool Equals(ref ValueAction other)
  • public bool Equals(ValueAction<T> other)
• public struct ValueAction<T1, T2> : ICallable<Action<T1, T2>>, ICallable, IEquatable<ValueAction<T1, T2>>
  • public bool IsEmpty { get; }
  • public bool Equals(ref ValueAction other)
  • public bool Equals(ValueAction<T1, T2> 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(ref ValueAction other)
  • public bool Equals(ValueAction<T1, T2, T3> 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(ref ValueAction other)
  • public bool Equals(ValueAction<T1, T2, T3, T4> 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(ref ValueAction other)
  • public bool Equals(ValueAction<T1, T2, T3, T4, T5> other)
• public struct ValueFunc<R> : ICallable<Func<R>>, ICallable, IEquatable<ValueFunc<R>>, ISupplier<R>
  • public bool IsEmpty { get; }
  • public bool Equals(ref ValueFunc other)
  • public bool Equals(ValueFunc<R> 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(ref ValueFunc other)
  • public bool Equals(ValueFunc<T, R> 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(ref ValueFunc other)
  • public bool Equals(ValueFunc<T1, T2, R> 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(ref ValueFunc other)
  • public bool Equals(ValueFunc<T1, T2, T3, R> 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(ref ValueFunc other)
  • public bool Equals(ValueFunc<T1, T2, T3, T4, R> 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(ref ValueFunc other)
  • public bool Equals(ValueFunc<T1, T2, T3, T4, T5, R> 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 ValueAction second)
  • public static bool op_Equality(ref ValueRefAction first, ref ValueRefAction second)
  • public static bool op_Inequality(ref ValueRefAction first, ref ValueAction second)
  • public bool Equals(ref ValueRefAction other)
  • public static bool op_Inequality(ref ValueRefAction first, ref ValueRefAction second)
  • public bool Equals(ValueRefAction<T, TArgs> other)
• public struct ValueRefFunc<T, TArgs, TResult> : ICallable<RefFunc<T, TArgs, TResult>>, ICallable, 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 bool TryGet<T>(this T? nullable, out T value) where T : struct
  • public static bool TryGet<T>(this ref Nullable 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 static T[] op_Implicit(ref ArrayRental rental)
  • public ArrayRental(T[] array, int length)
  • public ArrayRental(T[] array)
  • public static T[] op_Explicit(ref ArrayRental rental)
  • public ref T GetPinnableReference()
  • public ArraySegment<T> Slice(int offset, int count)
• public struct MemoryRental<T>
  • public bool IsEmpty { get; }
  • public ref T this[int index] { get; }
  • public int Length { get; }
  • public Span<T> Span { get; }
  • public MemoryRental(Span<T> span)
  • public MemoryRental(MemoryPool<T> pool, int minBufferSize)
  • public MemoryRental(int minBufferSize)
  • public static MemoryRental<T> op_Implicit(Span<T> span)
  • public void Dispose()
  • public ref T GetPinnableReference()

DotNext.Collections.Concurrent

• public class CopyOnWriteList<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IList<T>, ICollection<T>, ICloneable
  • public struct Enumerator<T> : IEnumerator<T>, IEnumerator, IDisposable
  • public ReadOnlyMemory<T> Snapshot { get; }
  • public Enumerator<T> GetEnumerator()
  • public Enumerator<T> GetEnumerator()

DotNext.Collections.Generic

• public static class List
  • public static int InsertOrdered<T>(this IList<T> list, T item, Comparison<T> comparer)

DotNext.Diagnostics

• public struct Timestamp : IEquatable<Timestamp>, IComparable<Timestamp>
  • public static Timestamp Current { get; }
  • public TimeSpan Elapsed { get; }
  • public TimeSpan Value { get; }
  • public static bool op_Equality(Timestamp first, Timestamp second)
  • public static bool op_GreaterThan(Timestamp first, Timestamp second)
  • public static bool op_GreaterThanOrEqual(Timestamp first, Timestamp second)
  • public static TimeSpan op_Implicit(Timestamp stamp)
  • public static bool op_Inequality(Timestamp first, Timestamp second)
  • public static bool op_LessThan(Timestamp first, Timestamp second)
  • public static bool op_LessThanOrEqual(Timestamp first, Timestamp second)
  • public int CompareTo(Timestamp other)
  • public bool Equals(Timestamp other)

DotNext.IO

• public static class StreamExtensions
  • public static long CopyTo(this Stream source, Stream destination, byte[] buffer, CancellationToken token = default)
  • public static Task<long> CopyToAsync(this Stream source, Stream destination, byte[] buffer, CancellationToken token = default)
  • public static T Read<T>(this Stream stream, byte[] buffer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static Task<T> ReadAsync<T>(this Stream stream, byte[] buffer, CancellationToken token = default) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static ReadOnlySpan<byte> ReadBytes(this Stream stream, int count, byte[] buffer)
  • public static Task<ReadOnlyMemory<byte>> ReadBytesAsync(this Stream stream, int count, byte[] buffer, CancellationToken token = default)
  • public static string ReadString(this Stream stream, int length, DecodingContext context, byte[] buffer)
  • public static Task<string> ReadStringAsync(this Stream stream, int length, DecodingContext context, byte[] buffer, CancellationToken token = default)
  • public static void Write<T>(this Stream stream, ref T value, byte[] buffer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static Task WriteAsync<T>(this Stream stream, ref T value, byte[] buffer, CancellationToken token = default) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void WriteString(this Stream stream, string value, EncodingContext context, byte[] buffer)
  • public static Task WriteStringAsync(this Stream stream, string value, EncodingContext context, byte[] buffer, CancellationToken token = default)
• public sealed class StreamSegment : Stream
  • public Stream BaseStream { get; }
  • public StreamSegment(Stream stream, bool leaveOpen = true)
  • public void Adjust(long offset, long length)

DotNext.Runtime

• public static class Intrinsics
  • public static bool HasFlag<T>(T value, T flag) where T : struct, Enum
  • public static RuntimeTypeHandle TypeOf<T>()

DotNext.Runtime.InteropServices

• public static class Memory
  • public static readonly Void* NullPtr
  • public static void Copy<T>(ref T source, ref T destination, uint count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void Copy<T>(T* input, T* output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static ref T GetBoxedValue<T>(object box) where T : struct
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReadonlyRef<T>(this T[] array, long index)
  • public static string ReadString(ref IntPtr source)
  • public static T* ToPointer<T>(this UIntPtr source) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static void WriteString(ref IntPtr destination, ReadOnlySpan<char> str)
  • public static void WriteString(ref IntPtr destination, string str)

DotNext.Text

• public struct DecodingContext
  • public Encoding Encoding { get; }
  • public DecodingContext(Encoding encoding, bool reuseDecoder = false)
  • public static DecodingContext op_Implicit(Encoding encoding)
  • public void Reset()
• public struct EncodingContext
  • public Encoding Encoding { get; }
  • public EncodingContext(Encoding encoding, bool reuseEncoder = false)
  • public static EncodingContext op_Implicit(Encoding encoding)
  • public void Reset()

DotNext.Threading

• public struct Atomic<T> : IStrongBox, ICloneable where T : struct
  • public void Clone(out Atomic container)
  • public Atomic<T> Clone()
• public struct ReaderWriterSpinLock
  • public struct LockStamp : IEquatable<LockStamp>
  • public int CurrentReadCount { get; }
  • public bool IsReadLockHeld { get; }
  • public bool IsWriteLockHeld { get; }
  • public void EnterReadLock()
  • public void EnterWriteLock()
  • public void ExitReadLock()
  • public void ExitWriteLock()
  • public bool TryEnterReadLock()
  • public bool TryEnterReadLock(TimeSpan timeout, CancellationToken token = default)
  • public bool TryEnterWriteLock()
  • public bool TryEnterWriteLock(TimeSpan timeout, CancellationToken token = default)
  • public LockStamp TryOptimisticRead()
  • public bool Validate(ref LockStamp stamp)
• public struct Timeout
  • public void ThrowIfExpired(out TimeSpan remaining)

DotNext.Threading.Tasks

• public abstract class Future : IFuture, INotifyCompletion
  • protected Future()
  • protected Future(bool runContinuationsAsynchronously = true)
• public abstract class Future<T> : Future where T : Task
  • protected Future()
  • protected Future(bool runContinuationsAsynchronously = true)

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)