DotNext by .NET Foundation and Contributors

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

---

API Diff between 4.8.1 and 4.1.1

281 Additions 7 Removals

DotNext

• public abstract class CharComparer : IEqualityComparer<char>, IComparer<char>
  • protected CharComparer()
  • public static int Compare(char x, char y, StringComparison comparisonType)
  • public static CharComparer Create(CultureInfo culture, CompareOptions options)
  • public static bool Equals(char x, char y, StringComparison comparisonType)
  • public static CharComparer FromComparison(StringComparison comparison)
  • public static int GetHashCode(char ch, StringComparison comparisonType)
  • public abstract int Compare(char x, char y)
  • public abstract bool Equals(char x, char y)
  • public abstract int GetHashCode(char ch)
• public static class DelegateHelpers
  • public static Func<bool> Bind<T>(this Predicate<T> predicate, T obj)
  • public static Predicate<T> Unbind<T>(this Func<bool> func)
• public struct DelegatingConsumer<T> : IConsumer<T>, IFunctional<Action<T>>
  • public static DelegatingConsumer<T> op_Implicit(Action<T> action)
• public abstract class Disposable : IDisposable
  • protected bool IsDisposing { get; }
  • protected bool IsDisposingOrDisposed { get; }
  • protected bool TryBeginDispose()
• public interface IBuildable<TSelf, TBuilder> where TSelf : IBuildable<TSelf, TBuilder> where TBuilder : ISupplier<TSelf>, IResettable
  • TBuilder CreateBuilder()
• public interface IOptionMonad<T> : ISupplier<object>, IFunctional<Func<object>>
  • T Value { get; }
• public interface IResettable
  • void Reset()
• public static class Optional
  • public static Optional<T> Flatten<T>(this ref Optional optional)
  • public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(ref Optional optional) where T : struct
• public static class RandomExtensions
  • public static void NextChars(this Random random, ReadOnlySpan<char> allowedChars, Span<char> buffer)
  • public static void NextChars(this RandomNumberGenerator random, ReadOnlySpan<char> allowedChars, Span<char> buffer)
• public static class Span
  • public static MemoryOwner<char> Concat(ReadOnlySpan<string> values, MemoryAllocator<char> allocator = null)
  • public static ReadOnlySpan<TBase> Contravariance<T, TBase>(this ReadOnlySpan<T> span) where T : TBase
  • public static Optional<T> FirstOrNone<T>(this ReadOnlySpan<T> span)
  • public static Optional<T> FirstOrNone<T>(this ReadOnlySpan<T> span, Predicate<T> filter)
  • public static Optional<T> LastOrNone<T>(this ReadOnlySpan<T> span)
• public struct UserDataSlot<TValue> : IEquatable<UserDataSlot<TValue>>
  • public bool IsAllocated { get; }
  • public UserDataSlot()
• public struct UserDataStorage
  • public bool IsValid { get; }
  • public IReadOnlyDictionary<string, object> Capture()

DotNext.Buffers

• public static class BufferHelpers
  • public static void Concat(this ref BufferWriterSlim writer, ReadOnlySpan<string> values)
  • public static void Concat(this IBufferWriter<char> writer, ReadOnlySpan<string> values)
  • public static Half ReadHalf(this ref SpanReader reader, bool isLittleEndian)
  • public static ReadOnlySequence<char> ToReadOnlySequence(this IEnumerable<string> strings)
  • public static void WriteHalf(this ref BufferWriterSlim builder, Half value, bool isLittleEndian)
  • public static void WriteHalf(this ref SpanWriter writer, Half value, bool isLittleEndian)
• public struct BufferWriterSlim<T>
  • public bool TryPeek(out T item)
  • public bool TryPop(out T item)
  • public bool TryPop(Span<T> output)
• public sealed class PooledArrayBufferWriter<T> : BufferWriter<T>, ISupplier<ArraySegment<T>>, IFunctional<Func<ArraySegment<T>>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
  • public PooledArrayBufferWriter()
  • public PooledArrayBufferWriter()
• public sealed class PooledBufferWriter<T> : BufferWriter<T>, IMemoryOwner<T>, IDisposable
  • public PooledBufferWriter()
• public struct PoolingInterpolatedStringHandler : IGrowableBuffer<char>, IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IDisposable, IResettable
  • public PoolingInterpolatedStringHandler(int literalLength, int formattedCount, MemoryAllocator<char> allocator, IFormatProvider provider = null)
  • public void AppendFormatted<T>(T value, string format = null)
  • public void AppendFormatted(ReadOnlySpan<char> value, int alignment)
  • public void AppendFormatted<T>(T value, int alignment, string format = null)
  • public void AppendFormatted(ReadOnlySpan<char> value)
  • public void AppendLiteral(string value)
  • public void Dispose()
• public struct SpanWriter<T>
  • public void Write<TArg>(method action, TArg arg, int count)
  • public void Write<TArg>(method action, TArg arg, int count)
• public class SparseBufferWriter<T> : Disposable, IGrowableBuffer<T>, IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>, IDisposable, IResettable, ISupplier<ReadOnlySequence<T>>, IFunctional<Func<ReadOnlySequence<T>>>, IEnumerable<ReadOnlyMemory<T>>, IEnumerable, IBufferWriter<T>
  • public SequencePosition End { get; }
  • public SequencePosition Start { get; }
  • public int CopyTo(Span<T> output, ref SequencePosition position)
  • public void CopyTo<TConsumer>(TConsumer consumer, SequencePosition start) where TConsumer : IReadOnlySpanConsumer<T>
  • public long CopyTo<TConsumer>(TConsumer consumer, ref SequencePosition position, long count) where TConsumer : IReadOnlySpanConsumer<T>
  • public SequencePosition GetPosition(long offset, SequencePosition origin = default)
  • public ReadOnlySequence<T> Read(ref SequencePosition position, long count)

DotNext.Buffers.Text

• public struct Base64Decoder
  • public bool NeedMoreData { get; }
  • public static IAsyncEnumerable<ReadOnlyMemory<byte>> DecodeFromUtf16Async(IAsyncEnumerable<ReadOnlyMemory<char>> chars, MemoryAllocator<byte> allocator = null, CancellationToken token = default)
  • public static IAsyncEnumerable<ReadOnlyMemory<byte>> DecodeFromUtf8Async(IAsyncEnumerable<ReadOnlyMemory<byte>> utf8Chars, MemoryAllocator<byte> allocator = null, CancellationToken token = default)
  • public void DecodeFromUtf16(ReadOnlySpan<char> chars, IBufferWriter<byte> output)
  • public void DecodeFromUtf16(ref ReadOnlySequence chars, IBufferWriter<byte> output)
  • public MemoryOwner<byte> DecodeFromUtf16(ReadOnlySpan<char> chars, MemoryAllocator<byte> allocator = null)
  • public void DecodeFromUtf16<TConsumer>(ReadOnlySpan<char> chars, TConsumer output) where TConsumer : IReadOnlySpanConsumer<byte>
  • public void DecodeFromUtf16<TArg>(ReadOnlySpan<char> chars, ReadOnlySpanAction<byte, TArg> callback, TArg arg)
  • public void DecodeFromUtf16<TArg>(ReadOnlySpan<char> chars, method callback, TArg arg)
  • public void DecodeFromUtf8(ReadOnlySpan<byte> utf8Chars, IBufferWriter<byte> output)
  • public void DecodeFromUtf8(ref ReadOnlySequence utf8Chars, IBufferWriter<byte> output)
  • public MemoryOwner<byte> DecodeFromUtf8(ReadOnlySpan<byte> utf8Chars, MemoryAllocator<byte> allocator = null)
  • public void DecodeFromUtf8<TConsumer>(ReadOnlySpan<byte> utf8Chars, TConsumer output) where TConsumer : IReadOnlySpanConsumer<byte>
  • public void DecodeFromUtf8<TArg>(ReadOnlySpan<byte> utf8Chars, ReadOnlySpanAction<byte, TArg> output, TArg arg)
  • public void DecodeFromUtf8<TArg>(ReadOnlySpan<byte> utf8Chars, method output, TArg arg)
  • public void DecodeFromUtf8(ReadOnlySpan<byte> utf8Chars, Stream output)
  • public void Reset()
• public struct Base64Encoder
  • public const int MaxBufferedDataSize = 2
  • public const int MaxCharsToFlush = 4
  • public const int MaxInputSize = 1610612733
  • public int BufferedDataSize { get; }
  • public bool HasBufferedData { get; }
  • public static IAsyncEnumerable<ReadOnlyMemory<char>> EncodeToCharsAsync(IAsyncEnumerable<ReadOnlyMemory<byte>> bytes, MemoryAllocator<char> allocator = null, CancellationToken token = default)
  • public static IAsyncEnumerable<ReadOnlyMemory<byte>> EncodeToUtf8Async(IAsyncEnumerable<ReadOnlyMemory<byte>> bytes, MemoryAllocator<byte> allocator = null, CancellationToken token = default)
  • public void EncodeToChars(ReadOnlySpan<byte> bytes, IBufferWriter<char> output, bool flush = false)
  • public MemoryOwner<char> EncodeToChars(ReadOnlySpan<byte> bytes, MemoryAllocator<char> allocator = null, bool flush = false)
  • public void EncodeToChars<TConsumer>(ReadOnlySpan<byte> bytes, TConsumer output, bool flush = false) where TConsumer : IReadOnlySpanConsumer<char>
  • public void EncodeToChars<TArg>(ReadOnlySpan<byte> bytes, ReadOnlySpanAction<char, TArg> output, TArg arg, bool flush = false)
  • public void EncodeToChars<TArg>(ReadOnlySpan<byte> bytes, method output, TArg arg, bool flush = false)
  • public void EncodeToChars(ReadOnlySpan<byte> bytes, TextWriter output, bool flush = false)
  • public void EncodeToChars(ReadOnlySpan<byte> bytes, StringBuilder output, bool flush = false)
  • public void EncodeToUtf8(ReadOnlySpan<byte> bytes, IBufferWriter<byte> output, bool flush = false)
  • public MemoryOwner<byte> EncodeToUtf8(ReadOnlySpan<byte> bytes, MemoryAllocator<byte> allocator = null, bool flush = false)
  • public void EncodeToUtf8<TConsumer>(ReadOnlySpan<byte> bytes, TConsumer output, bool flush = false) where TConsumer : IReadOnlySpanConsumer<byte>
  • public void EncodeToUtf8<TArg>(ReadOnlySpan<byte> bytes, ReadOnlySpanAction<byte, TArg> output, TArg arg, bool flush = false)
  • public void EncodeToUtf8<TArg>(ReadOnlySpan<byte> bytes, method output, TArg arg, bool flush = false)
  • public void EncodeToUtf8(ReadOnlySpan<byte> bytes, Stream output, bool flush = false)
  • public int Flush(Span<char> output)
  • public int Flush(Span<byte> output)
  • public int GetBufferedData(Span<byte> output)
  • public void Reset()
• public static class Hex
  • public static int DecodeFromUtf16(ReadOnlySpan<char> chars, Span<byte> output)
  • public static int DecodeFromUtf8(ReadOnlySpan<byte> chars, Span<byte> output)
  • public static int EncodeToUtf16(ReadOnlySpan<byte> bytes, Span<char> output, bool lowercased = false)
  • public static string EncodeToUtf16(ReadOnlySpan<byte> bytes, bool lowercased = false)
  • public static int EncodeToUtf8(ReadOnlySpan<byte> bytes, Span<byte> output, bool lowercased = false)
  • public static byte[] EncodeToUtf8(ReadOnlySpan<byte> bytes, bool lowercased = false)

DotNext.Collections.Generic

• public static class Dictionary
  • public static IReadOnlyDictionary<TKey, TValue> Empty<TKey, TValue>()
• public static class Sequence
  • public static Task<MemoryOwner<T>> CopyAsync<T>(this IAsyncEnumerable<T> enumerable, int sizeHint = 0, MemoryAllocator<T> allocator = null, CancellationToken token = default)
  • public static Optional<T> FirstOrNone<T>(this IEnumerable<T> seq)
  • public static Optional<T> FirstOrNone<T>(this IEnumerable<T> seq, Predicate<T> filter)
  • public static ValueTask<Optional<T>> FirstOrNoneAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default)
  • public static ValueTask<Optional<T>> FirstOrNoneAsync<T>(this IAsyncEnumerable<T> seq, Predicate<T> filter, CancellationToken token = default)
  • public static Optional<T> LastOrNone<T>(this IEnumerable<T> seq)
  • public static ValueTask<Optional<T>> LastOrNoneAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default)
  • public static T? LastOrNull<T>(this IEnumerable<T> seq) where T : struct
  • public static ValueTask<T?> LastOrNullAsync<T>(this IAsyncEnumerable<T> seq, CancellationToken token = default) where T : struct

DotNext.Collections.Specialized

• public class ConcurrentTypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>
  • public struct Enumerator<TValue>
  • public Enumerator<TValue> GetEnumerator()
  • public bool Set<TKey>(TValue newValue, out TValue oldValue)
• public static class InvocationList
  • public static void Invoke<T>(this ref InvocationList actions, T arg)
  • public static void Invoke<T1, T2>(this ref InvocationList actions, T1 arg1, T2 arg2)
  • public static void Invoke<T>(this InvocationList<Action<T>> actions, T arg)
  • public static void Invoke<T1, T2>(this InvocationList<Action<T1, T2>> actions, T1 arg1, T2 arg2)
• public interface ITypeMap<TValue> : IReadOnlyTypeMap<TValue>
  • bool Set<TKey>(TValue newValue, out TValue oldValue)
• public class TypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>
  • public struct Enumerator<TValue>
  • public Enumerator<TValue> GetEnumerator()
  • public bool Set<TKey>(TValue newValue, out TValue oldValue)

DotNext.Diagnostics

• public struct Timestamp : IEquatable<Timestamp>, IComparable<Timestamp>
  • public double ElapsedMilliseconds { get; }
  • public long ElapsedTicks { get; }
  • public bool IsEmpty { get; }
  • public bool IsFuture { get; }
  • public bool IsPast { get; }
  • public Timestamp()
  • public Timestamp(TimeSpan ts)
  • public static TimeSpan op_Explicit(Timestamp stamp)
  • public static TimeSpan op_Implicit(Timestamp stamp)
  • public static void Refresh(ref Timestamp location)
  • public double ElapsedSince(Timestamp past)

DotNext.Numerics

• public static class BitVector
  • public static void FromInt(IntPtr value, Span<bool> bits)
  • public static void FromUInt(UIntPtr value, Span<bool> bits)
  • public static IntPtr ToInt(ReadOnlySpan<bool> bits)
  • public static UIntPtr ToUInt(ReadOnlySpan<bool> bits)

DotNext.Reflection

• public static class PropertyExtensions
  • public static bool IsExternalInit(this PropertyInfo property)
• public static class TaskType
  • public static Func<bool> GetIsCompletedGetter(this Task task)

DotNext.Runtime

• public abstract class BoxedValue<T> where T : struct
  • public ref T Value { get; }
  • public static BoxedValue<T> Box(T value)
  • public static BoxedValue<T> GetTypedReference(object boxedValue)
  • public static BoxedValue<T> op_Explicit(T value)
  • public static BoxedValue<T> op_Explicit(ref Nullable value)
  • public static T op_Implicit(BoxedValue<T> boxedValue)
  • public static BoxedValue<T> TryBox(ref Nullable value)
  • public abstract bool Equals(object obj)
  • public abstract int GetHashCode()
  • public abstract string ToString()
• public struct GCLatencyModeScope : IDisposable
  • public static GCLatencyModeScope LowLatency { get; }
  • public static GCLatencyModeScope SustainedLowLatency { get; }
  • public GCLatencyModeScope(GCLatencyMode mode)
  • public void Dispose()
• public abstract class GCNotification
  • public struct Registration : IDisposable
  • public static GCNotification GCTriggered()
  • public static GCNotification GCTriggered(int generation)
  • public static GCNotification HeapCompaction()
  • public static GCNotification HeapFragmentation(double threshold)
  • public static GCNotification MemoryThreshold(double threshold)
  • public static GCNotification op_BitwiseAnd(GCNotification left, GCNotification right)
  • public static GCNotification op_BitwiseOr(GCNotification left, GCNotification right)
  • public static GCNotification op_ExclusiveOr(GCNotification left, GCNotification right)
  • public static GCNotification op_LogicalNot(GCNotification filter)
  • public virtual GCNotification And(GCNotification right)
  • public virtual GCNotification ExclusiveOr(GCNotification right)
  • public virtual GCNotification Negate()
  • public virtual GCNotification Or(GCNotification right)
  • public Registration Register<T>(Action<T, GCMemoryInfo> callback, T state, bool captureContext = false)
  • public Task<GCMemoryInfo> WaitAsync(TimeSpan timeout, CancellationToken token = default)
  • public Task<GCMemoryInfo> WaitAsync(CancellationToken token = default)
• public static class Intrinsics
  • public static void ClearBits(Void* address, UIntPtr length)
  • public static int Compare(Void* first, Void* second, UIntPtr length)
  • public static void Copy<T>(ref T source, out T destination, UIntPtr count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static bool Equals(Void* first, Void* second, UIntPtr length)
  • public static void Finalize(object obj)
  • public static int GetHashCode32(Void* source, UIntPtr length, int hash, Func<int, int, int> hashFunction, bool salted = true)
  • public static int GetHashCode32<THashFunction>(Void* source, UIntPtr length, bool salted = true) where THashFunction : struct, IConsumer<int>, ISupplier<int>
  • public static int GetHashCode32(Void* source, UIntPtr length, bool salted = true)
  • public static long GetHashCode64(Void* source, UIntPtr length, long hash, Func<long, long, long> hashFunction, bool salted = true)
  • public static long GetHashCode64<THashFunction>(Void* source, UIntPtr length, bool salted = true) where THashFunction : struct, IConsumer<long>, ISupplier<long>
  • public static long GetHashCode64(Void* source, UIntPtr length, bool salted = true)
  • public static bool HasFinalizer(object obj)
• public sealed class SoftReference<T> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>
  • public ValueTuple<T, SoftReferenceState> TargetAndState { get; }
  • public SoftReference(T target, SoftReferenceOptions options = null)
  • public static T op_Explicit(SoftReference<T> reference)
  • public static Optional<T> op_Explicit(SoftReference<T> reference)
  • public void Clear()
  • public bool TryGetTarget(out T target)
  • public Optional<T> TryGetTarget()
• public class SoftReferenceOptions
  • public static SoftReferenceOptions Default { get; }
  • public int CollectionCount { get; set; }
  • public long MemoryLimit { get; set; }
  • public double MemoryThreshold { get; set; }
  • public SoftReferenceOptions()
• public enum SoftReferenceState
  • Empty = 0
  • Strong = 2
  • Weak = 1

DotNext.Runtime.Caching

• public enum CacheEvictionPolicy
  • LFU = 1
  • LRU = 0
• public class ConcurrentCache<TKey, TValue> : IReadOnlyDictionary<TKey, TValue>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyCollection<KeyValuePair<TKey, TValue>>
  • public int Capacity { get; }
  • public int Count { get; }
  • public Action<TKey, TValue> Eviction { get; set; }
  • public bool ExecuteEvictionAsynchronously { get; set; }
  • public TValue this[TKey key] { get; set; }
  • public ConcurrentCache(int capacity, int concurrencyLevel, CacheEvictionPolicy evictionPolicy, IEqualityComparer<TKey> keyComparer = null)
  • public ConcurrentCache(int capacity, CacheEvictionPolicy evictionPolicy, IEqualityComparer<TKey> keyComparer = null)
  • public TValue AddOrUpdate(TKey key, TValue value, out bool added)
  • public void Clear()
  • public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
  • public TValue GetOrAdd(TKey key, TValue value, out bool added)
  • public int TakeSnapshot(Span<KeyValuePair<TKey, TValue>> buffer, bool descendingOrder = true)
  • public bool TryAdd(TKey key, TValue value)
  • public bool TryGetValue(TKey key, out TValue value)
  • public bool TryRemove(TKey key, out TValue value)
  • public bool TryRemove(KeyValuePair<TKey, TValue> pair)
  • public bool TryUpdate(TKey key, TValue newValue, TValue expectedValue)

DotNext.Runtime.CompilerServices

• public sealed class FunctionalInterfaceAttribute : Attribute
• public interface IFunctional<TDelegate> where TDelegate : Delegate
  • TDelegate ToDelegate()
• public struct Scope : IDisposable, IAsyncDisposable
  • public void Defer(Action callback)
  • public void Defer(Func<ValueTask> callback)
  • public void Dispose()
  • public ValueTask DisposeAsync()
  • public void RegisterForDispose(IDisposable disposable)
  • public void RegisterForDisposeAsync(IAsyncDisposable disposable)

DotNext.Text

• public struct Base64Decoder
  • public static IAsyncEnumerable<ReadOnlyMemory<byte>> DecodeAsync(IAsyncEnumerable<ReadOnlyMemory<char>> chars, MemoryAllocator<byte> allocator = null, CancellationToken token = default)
  • public static IAsyncEnumerable<ReadOnlyMemory<byte>> DecodeAsync(IAsyncEnumerable<ReadOnlyMemory<byte>> utf8Chars, MemoryAllocator<byte> allocator = null, CancellationToken token = default)
  • public MemoryOwner<byte> Decode(ReadOnlySpan<char> chars, MemoryAllocator<byte> allocator = null)
  • public MemoryOwner<byte> Decode(ReadOnlySpan<byte> utf8Chars, MemoryAllocator<byte> allocator = null)
  • public void Reset()
• public struct Base64Encoder
  • public const int MaxBufferedDataSize = 2
  • public const int MaxCharsToFlush = 4
  • public const int MaxInputSize = 1610612733
  • public int BufferedDataSize { get; }
  • public bool HasBufferedData { get; }
  • public static IAsyncEnumerable<ReadOnlyMemory<char>> EncodeToCharsAsync(IAsyncEnumerable<ReadOnlyMemory<byte>> bytes, MemoryAllocator<char> allocator = null, CancellationToken token = default)
  • public static IAsyncEnumerable<ReadOnlyMemory<byte>> EncodeToUtf8Async(IAsyncEnumerable<ReadOnlyMemory<byte>> bytes, MemoryAllocator<byte> allocator = null, CancellationToken token = default)
  • public void EncodeToChars(ReadOnlySpan<byte> bytes, IBufferWriter<char> output, bool flush = false)
  • public MemoryOwner<char> EncodeToChars(ReadOnlySpan<byte> bytes, MemoryAllocator<char> allocator = null, bool flush = false)
  • public void EncodeToChars<TConsumer>(ReadOnlySpan<byte> bytes, TConsumer output, bool flush = false) where TConsumer : IReadOnlySpanConsumer<char>
  • public void EncodeToChars<TArg>(ReadOnlySpan<byte> bytes, ReadOnlySpanAction<char, TArg> output, TArg arg, bool flush = false)
  • public void EncodeToChars<TArg>(ReadOnlySpan<byte> bytes, method output, TArg arg, bool flush = false)
  • public void EncodeToChars(ReadOnlySpan<byte> bytes, TextWriter output, bool flush = false)
  • public void EncodeToChars(ReadOnlySpan<byte> bytes, StringBuilder output, bool flush = false)
  • public void EncodeToUtf8(ReadOnlySpan<byte> bytes, IBufferWriter<byte> output, bool flush = false)
  • public MemoryOwner<byte> EncodeToUtf8(ReadOnlySpan<byte> bytes, MemoryAllocator<byte> allocator = null, bool flush = false)
  • public void EncodeToUtf8<TConsumer>(ReadOnlySpan<byte> bytes, TConsumer output, bool flush = false) where TConsumer : IReadOnlySpanConsumer<byte>
  • public void EncodeToUtf8<TArg>(ReadOnlySpan<byte> bytes, ReadOnlySpanAction<byte, TArg> output, TArg arg, bool flush = false)
  • public void EncodeToUtf8<TArg>(ReadOnlySpan<byte> bytes, method output, TArg arg, bool flush = false)
  • public void EncodeToUtf8(ReadOnlySpan<byte> bytes, Stream output, bool flush = false)
  • public int Flush(Span<char> output)
  • public int Flush(Span<byte> output)
  • public int GetBufferedData(Span<byte> output)
  • public void Reset()
• public static class InterpolatedString
  • public static MemoryOwner<char> Allocate(MemoryAllocator<char> allocator, IFormatProvider provider, ref PoolingInterpolatedStringHandler handler)
  • public static MemoryOwner<char> Allocate(MemoryAllocator<char> allocator, ref PoolingInterpolatedStringHandler handler)
• public struct StringBuilderConsumer : IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IEquatable<StringBuilderConsumer>
  • public bool IsEmpty { get; }
  • public StringBuilderConsumer(StringBuilder builder)
  • public static bool op_Equality(StringBuilderConsumer x, StringBuilderConsumer y)
  • public static StringBuilderConsumer op_Implicit(StringBuilder builder)
  • public static bool op_Inequality(StringBuilderConsumer x, StringBuilderConsumer y)
  • public bool Equals(StringBuilderConsumer other)

DotNext.Threading

• public struct Timeout
  • public static Timeout Expired { get; }