API Diff between 0.1.1 and 5.3.1
515 Additions
431 Removals
DotNext
-
public struct Activator<T> : ISupplier<T>, IFunctional<Func<T>>
-
public static class BasicExtensions
-
public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
-
public abstract class CharComparer : IEqualityComparer<char>, IComparer<char>
-
public enum BoundType
-
public struct Consumer<T> : IConsumer<T>, IFunctional<Action<T>>
-
public struct ConsumerClosure<TContext, T> : IConsumer<T>, IFunctional<Action<T>>
-
public static class Comparable
- 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 Converter
- public static Func<TInput, TOutput> AsFunc<TInput, TOutput>(this Converter<TInput, TOutput> converter)
- public static Func<I, O> AsFunc<I, O>(this Converter<I, O> converter)
- public static Converter<TInput, TOutput> Identity<TInput, TOutput>() where TInput : TOutput
- public static Converter<I, O> Identity<I, O>() where I : O
- public static Result<TOutput> TryInvoke<TInput, TOutput>(this Converter<TInput, TOutput> converter, TInput input)
-
public static class DelegateHelpers
- public static Action Bind<T>(this Action<T> action, T obj)
- public static Func<TResult> Bind<T, TResult>(this Func<T, TResult> func, T obj)
- public static Func<T2, TResult> Bind<T1, T2, TResult>(this Func<T1, T2, TResult> func, T1 obj)
- public static Action<T2> Bind<T1, T2>(this Action<T1, T2> action, T1 obj)
- public static Func<T2, T3, TResult> Bind<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> func, T1 obj)
- public static Action<T2, T3> Bind<T1, T2, T3>(this Action<T1, T2, T3> action, T1 obj)
- public static Func<T2, T3, T4, TResult> Bind<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> func, T1 obj)
- public static Action<T2, T3, T4> Bind<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T1 obj)
- public static Func<T2, T3, T4, T5, TResult> Bind<T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> func, T1 obj)
- public static Action<T2, T3, T4, T5> Bind<T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action, T1 obj)
- public static Func<bool> Bind<T>(this Predicate<T> predicate, T obj)
- public static TDelegate ChangeType<TDelegate>(this Delegate d) where TDelegate : Delegate
- public static EventHandler<T> Contravariant<TBase, T>(this EventHandler<TBase> handler) where T : TBase
- public static Func<object, TDelegate> CreateClosedDelegateFactory<TDelegate>(Expression<TDelegate> expression) where TDelegate : Delegate
- 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 TDelegate CreateOpenDelegate<TDelegate>(Expression<TDelegate> expression) where TDelegate : Delegate
- public static Action<T, TValue> CreateOpenDelegate<T, TValue>(Expression<Func<T, TValue>> properyExpr)
- public static Action<T> Unbind<T>(this Action action)
- public static Func<T, TResult> Unbind<T, TResult>(this Func<TResult> func)
- public static Func<T, TArg, TResult> Unbind<T, TArg, TResult>(this Func<TArg, TResult> func)
- public static Action<T, TArg> Unbind<T, TArg>(this Action<TArg> action)
- public static Func<T, T1, T2, TResult> Unbind<T, T1, T2, TResult>(this Func<T1, T2, TResult> func)
- public static Action<T, T1, T2> Unbind<T, T1, T2>(this Action<T1, T2> action)
- public static Func<T, T1, T2, T3, TResult> Unbind<T, T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> func)
- public static Action<T, T1, T2, T3> Unbind<T, T1, T2, T3>(this Action<T1, T2, T3> action)
- public static Func<T, T1, T2, T3, T4, TResult> Unbind<T, T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> func)
- public static Action<T, T1, T2, T3, T4> Unbind<T, T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action)
- public static Func<T, T1, T2, T3, T4, T5, TResult> Unbind<T, T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> func)
- public static Action<T, T1, T2, T3, T4, T5> Unbind<T, T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action)
- public static Predicate<T> Unbind<T>(this Func<bool> func)
- public static D ChangeType<D>(this Delegate d) where D : Delegate
- public static EventHandler<O> Contravariant<I, O>(this EventHandler<I> handler) where O : I
- public static D CreateDelegate<D>(this MethodInfo method, object target = null) where D : Delegate
-
public struct DelegatingConsumer<T> : IConsumer<T>, IFunctional<Action<T>>, IEquatable<DelegatingConsumer<T>>
-
public struct DelegatingSupplier<TResult> : ISupplier<TResult>, IFunctional<Func<TResult>>, IEquatable<DelegatingSupplier<TResult>>
-
public struct DelegatingSupplier<T, TResult> : ISupplier<T, TResult>, IFunctional<Func<T, TResult>>, IEquatable<DelegatingSupplier<T, TResult>>
-
public struct DelegatingSupplier<T1, T2, TResult> : ISupplier<T1, T2, TResult>, IFunctional<Func<T1, T2, TResult>>, IEquatable<DelegatingSupplier<T1, T2, TResult>>
-
public struct DisclosedEndpoint<T> : IFiniteRangeEndpoint<T>, IRangeEndpoint<T> where T : IComparable<T>
-
public abstract class Disposable : IDisposable
-
public struct EnclosedEndpoint<T> : IFiniteRangeEndpoint<T>, IRangeEndpoint<T> where T : IComparable<T>
-
public static class EnumConverter
-
public struct EqualityComparerBuilder<T>
-
public struct Enum<E> : IEquatable<E>, IComparable<E>, IFormattable where E : struct, Enum
-
public static class Func
- public static Converter<TInput, TOutput> AsConverter<TInput, TOutput>(this Func<TInput, TOutput> function)
- public static Converter<I, O> AsConverter<I, O>(this Func<I, O> function)
- public static Func<T> Constant<T>(T obj)
- public static Func<TInput, TOutput> Identity<TInput, TOutput>() where TInput : TOutput
- public static Func<I, O> Identity<I, O>() where I : O
- public static Func<T, T> Identity<T>(this Action<T> action)
- public static Func<T, bool> IsNotNull<T>()
- public static Func<T, bool> IsNull<T>()
- public static Func<object, bool> IsTypeOf<T>()
- public static Result<TResult> TryInvoke<TResult>(this Func<TResult> function)
- public static Result<TResult> TryInvoke<T, TResult>(this Func<T, TResult> function, T arg)
- public static Result<TResult> TryInvoke<T1, T2, TResult>(this Func<T1, T2, TResult> function, T1 arg1, T2 arg2)
- public static Result<TResult> TryInvoke<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> function, T1 arg1, T2 arg2, T3 arg3)
- public static Result<TResult> TryInvoke<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
- public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
- public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, TResult>(this Func<T1, T2, T3, T4, T5, T6, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
- public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, T7, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
- public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
- public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
- public static Result<TResult> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
-
public interface IConsumer<T> : IFunctional<Action<T>>
-
public interface IFiniteRangeEndpoint<T> : IRangeEndpoint<T>
-
public interface IOptionMonad<T> : ISupplier<object>, IFunctional<Func<object>>
-
public interface IOptionMonad<T, TSelf> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>> where TSelf : struct, IOptionMonad<T, TSelf>
-
public interface IRangeEndpoint<T>
-
public interface IResettable
-
public interface IResultMonad<T, TError> : IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>
-
public interface IResultMonad<T, TError, TSelf> : IResultMonad<T, TError>, IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>, IOptionMonad<T, TSelf> where TSelf : struct, IResultMonad<T, TError, TSelf>
-
public interface ISupplier<TResult> : IFunctional<Func<TResult>>
-
public interface ISupplier<T, TResult> : IFunctional<Func<T, TResult>>
-
public interface ISupplier<T1, T2, TResult> : IFunctional<Func<T1, T2, TResult>>
-
public interface IOptional
-
public sealed delegate ItemAction<I, V> : MulticastDelegate
-
public static class ObjectExtensions
- public static void Decompose<T, R1, R2>(this T obj, Func<T, R1> decomposer1, Func<T, R2> decomposer2, out R1 result1, out R2 result2)
- public static ValueTuple<R1, R2> Decompose<T, R1, R2>(this T obj, Func<T, R1> decomposer1, Func<T, R2> decomposer2)
- public static UserDataStorage GetUserData<T>(this T obj)
- public static bool IsOneOf<T>(this T value, IEnumerable<T> values)
- public static bool IsOneOf<T>(this T value, T[] values)
-
public static class OneDimensionalArray
- public static int BitwiseCompare<T>(this T[] first, T[] second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static bool BitwiseEquals<T>(this T[] first, T[] second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T>(this T[] array, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T>(this T[] array, int hash, Func<int, int, int> hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static O[] Convert<I, O>(this I[] input, Converter<I, O> mapper)
- public static O[] Convert<I, O>(this I[] input, Func<long, I, O> mapper)
- public static void ForEach<T>(this T[] array, ItemAction<long, T> action)
- public static T[] Insert<T>(this T[] array, T element, long index)
- public static bool IsNullOrEmpty<T>(this T[] array)
- public static T[] New<T>(long length)
- public static T[] RemoveFirst<T>(this T[] input, long count)
- public static T[] RemoveLast<T>(this T[] input, long count)
- public static bool SequenceEqual<T>(this T[] first, T[] second) where T : IEquatable<T>
- public static T[] Slice<T>(this T[] input, long startIndex, long length)
-
public static class Optional
- public static Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<Optional<TInput>> task, Converter<TInput, TOutput> converter)
- public static Optional<T> Create<T, TMonad>(TMonad value) where TMonad : struct, IOptionMonad<T>
- public static Optional<T> Flatten<T>(this ref Optional optional)
- public static Task<Optional<O>> Convert<I, O>(this Task<Optional<I>> task, Converter<I, O> converter)
- public static Optional<T> EmptyIfNull<T>(this T value)
- public static Optional<T> None<T>()
- public static Optional<T> Null<T>()
- public static Task<T?> OrNull<T>(this Task<Optional<T>> task) where T : struct
- public static Task<T> OrThrow<T, TException>(this Task<Optional<T>> task, Func<TException> exceptionFactory) where TException : Exception
- public static Optional<T> Some<T>(T value)
- public static Task<T> OrThrow<T, E>(this Task<Optional<T>> task, Func<E> exceptionFactory) where E : Exception
-
public struct Optional<T> : IOptional, IEquatable<Optional<T>>, IEquatable<T>, IStructuralEquatable
-
public static class Predicate
-
public static class RandomExtensions
- public static void GetItems<T>(this Random random, Span<T> buffer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void GetItems<T>(this RandomNumberGenerator random, Span<T> buffer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- 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 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 string NextString(this Random random, ReadOnlySpan<char> allowedChars, int length)
- public static string NextString(this Random random, char[] allowedChars, int length)
- public static string NextString(this RandomNumberGenerator random, ReadOnlySpan<char> allowedChars, int length)
- public static string NextString(this RandomNumberGenerator random, char[] allowedChars, int length)
- public static Optional<T> Peek<T>(this Random random, IReadOnlyCollection<T> collection)
- public static Optional<T> Peek<T>(this Random random, ReadOnlySpan<T> span)
- public static void Shuffle<T>(this Random random, IList<T> list)
-
public sealed delegate RefAction<T, TArgs> : MulticastDelegate
-
public sealed delegate RefFunc<T, TArgs, TResult> : MulticastDelegate
-
public static class Range
-
public static class Result
-
public struct Result<T> : IResultMonad<T, Exception, Result<T>>, IResultMonad<T, Exception>, IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>, IOptionMonad<T, Result<T>>
-
public struct Result<T, TError> : IResultMonad<T, TError, Result<T, TError>>, IResultMonad<T, TError>, IOptionMonad<T>, ISupplier<object>, IFunctional<Func<object>>, IOptionMonad<T, Result<T, TError>> where TError : struct, Enum
-
public static class ServiceProviderFactory
-
public static class Span
-
public static class Sequence
-
public static class StringExtensions
-
public struct Supplier<TResult> : ISupplier<TResult>, IFunctional<Func<TResult>>
-
public struct Supplier<T, TResult> : ISupplier<T, TResult>, IFunctional<Func<T, TResult>>
-
public struct Supplier<T1, T2, TResult> : ISupplier<T1, T2, TResult>, IFunctional<Func<T1, T2, TResult>>
-
public struct SupplierClosure<TContext, TResult> : ISupplier<TResult>, IFunctional<Func<TResult>>
-
public struct SupplierClosure<TContext, T, TResult> : ISupplier<T, TResult>, IFunctional<Func<T, TResult>>
-
public struct SupplierClosure<TContext, T1, T2, TResult> : ISupplier<T1, T2, TResult>, IFunctional<Func<T1, T2, TResult>>
-
public static class TupleExtensions
-
public sealed class UndefinedResultException<TError> : Exception where TError : struct, Enum
-
public struct UserDataSlot<V> : IEquatable<UserDataSlot<V>>
-
public struct UserDataStorage
- public interface IContainer
- public bool IsValid { get; }
- public IReadOnlyDictionary<string, object> Capture()
- public void CopyTo(object obj)
- public TValue Get<TValue>(UserDataSlot<TValue> slot, TValue defaultValue)
- public TValue Get<TValue>(UserDataSlot<TValue> slot)
- public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot)
- public TBase GetOrSet<TBase, T>(UserDataSlot<TBase> slot) where T : TBase
- public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot, Func<TValue> valueFactory)
- public TValue GetOrSet<TValue>(UserDataSlot<TValue> slot, method valueFactory)
- public TValue GetOrSet<T, TValue>(UserDataSlot<TValue> slot, T arg, Func<T, TValue> 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, Func<T1, T2, TValue> 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 bool Remove<TValue>(UserDataSlot<TValue> slot)
- public bool Remove<TValue>(UserDataSlot<TValue> slot, out TValue userData)
- public void Set<TValue>(UserDataSlot<TValue> slot, TValue userData)
- public bool TryGet<TValue>(UserDataSlot<TValue> slot, out TValue userData)
- public V Get<V>(UserDataSlot<V> slot, V defaultValue = null)
- public V GetOrSet<V>(UserDataSlot<V> slot)
- public V GetOrSet<V>(UserDataSlot<V> slot, Func<V> valueFactory)
- public bool Remove<V>(UserDataSlot<V> slot)
- public bool Remove<V>(UserDataSlot<V> slot, out V userData)
- public void Set<V>(UserDataSlot<V> slot, V userData)
- public bool TryGet<V>(UserDataSlot<V> slot, out V userData)
-
public struct ValueSupplier<T> : ISupplier<T>, IFunctional<Func<T>>
-
public sealed class ValueType<T> : StrongBox<T> where T : struct
- public static readonly bool IsPrimitive
- public static IComparer<T> Comparer { get; }
- public static T Default { get; }
- public static IEqualityComparer<T> EqualityComparer { get; }
- public static int Size { get; }
- public ValueType(T value)
- public static byte[] AsBinary(T value)
- public static void BitCast<TO>(ref T input, out TO output) where TO : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseCompare(T first, T second)
- public static int BitwiseCompare<U>(T first, U second) where U : struct
- public static bool BitwiseEquals<U>(T first, U second) where U : struct
- public static bool BitwiseEquals(T first, T second)
- public static int BitwiseHashCode(T value, int hash, Func<int, int, int> hashFunction, bool salted = true)
- public static int BitwiseHashCode(T value, bool salted = true)
- public static bool IsDefault(T value)
- public static T op_Implicit(ValueType<T> box)
- public ref T GetPinnableReference()
-
public static class ValueTypeExtensions
DotNext.Buffers
-
public struct BufferConsumer<T> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>, IEquatable<BufferConsumer<T>>
-
public abstract class BufferWriter<T> : Disposable, IBufferWriter<T>, ISupplier<ReadOnlyMemory<T>>, IFunctional<Func<ReadOnlyMemory<T>>>, IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IGrowableBuffer<T>, IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>, IDisposable, IResettable
-
public struct BufferWriterInterpolatedStringHandler
-
public struct BufferWriterSlim<T>
-
public struct BufferWriterSlimInterpolatedStringHandler
-
public static class ByteBuffer
-
public static class CharBuffer
-
public struct DelegatingReadOnlySpanConsumer<T, TArg> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>
-
public interface IGrowableBuffer<T> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>, IDisposable, IResettable
-
public interface IReadOnlySpanConsumer<T> : ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>
-
public static class Memory
-
public sealed delegate MemoryAllocator<T> : MulticastDelegate
-
public struct MemoryOwner<T> : IMemoryOwner<T>, IDisposable, ISupplier<Memory<T>>, IFunctional<Func<Memory<T>>>, ISupplier<ReadOnlyMemory<T>>, IFunctional<Func<ReadOnlyMemory<T>>>
-
public sealed class PoolingArrayBufferWriter<T> : BufferWriter<T>, ISupplier<ArraySegment<T>>, IFunctional<Func<ArraySegment<T>>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
-
public sealed class PoolingBufferWriter<T> : BufferWriter<T>, IMemoryOwner<T>, IDisposable
-
public struct PoolingInterpolatedStringHandler : IGrowableBuffer<char>, IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IDisposable, IResettable
-
public static class ReadOnlySequencePartitioner
-
public struct ReadOnlySpanConsumer<T, TArg> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<T>, CancellationToken, ValueTask>>
-
public struct SpanOwner<T>
-
public struct SpanReader<T>
-
public struct SpanWriter<T>
-
public enum SparseBufferGrowth
-
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 struct ArrayRental<T> : IDisposable
DotNext.Buffers.Binary
DotNext.Buffers.Text
DotNext.Collections.Generic
-
public static class AsyncEnumerable
-
public static class Collection
- public struct ConsumingEnumerable<T> : IEnumerable<T>, IEnumerable
- public static IEnumerable<T> Append<T>(this IEnumerable<T> collection, T[] items)
- public static ReadOnlyCollectionView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyCollection<TInput> collection, Converter<TInput, TOutput> converter)
- public static MemoryOwner<T> Copy<T>(this IEnumerable<T> enumerable, int sizeHint = 0, MemoryAllocator<T> allocator = null)
- public static bool ElementAt<T>(this IEnumerable<T> collection, int index, out T element)
- public static void ForEach<T>(this IEnumerable<T> collection, Action<T> action)
- public static ValueTask ForEachAsync<T>(this IEnumerable<T> collection, Func<T, CancellationToken, ValueTask> action, CancellationToken token = default)
- public static ConsumingEnumerable<T> GetConsumer<T>(this IProducerConsumerCollection<T> collection)
- public static IEnumerable<T> Prepend<T>(this IEnumerable<T> collection, T[] items)
- public static int SequenceHashCode<T>(this IEnumerable<T> sequence, bool salted = true)
- public static IEnumerable<T> SkipNulls<T>(this IEnumerable<T> collection)
- public static ReadOnlyCollectionView<T> AsReadOnlyView<T>(this ICollection<T> collection)
- public static ReadOnlyCollectionView<I, O> Convert<I, O>(this IReadOnlyCollection<I> collection, Converter<I, O> converter)
- public static IAsyncEnumerable<T> ToAsyncEnumerable<T>(this IEnumerable<T> enumerable)
- public static string ToString<T>(this IEnumerable<T> collection, string delimiter, string ifEmpty = "")
-
public static class Dictionary
- public static ReadOnlyDictionaryView<TKey, TValue, TResult> ConvertValues<TKey, TValue, TResult>(this IReadOnlyDictionary<TKey, TValue> dictionary, Converter<TValue, TResult> mapper)
- public static void ForEach<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, Action<TKey, TValue> action)
- public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key)
- public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key, TValue value)
- 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, Func<TKey, TValue> 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, Func<TValue> defaultValue)
- public static Func<TKey, TValue> IndexerGetter<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary)
- public static Func<TKey, TValue> IndexerGetter<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
- public static Action<TKey, TValue> IndexerSetter<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
- 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 Optional<TValue> TryGetValue<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
- public static Optional<TValue> TryGetValue<TKey, TValue>(IReadOnlyDictionary<TKey, TValue> dictionary, TKey key)
- public static Optional<TValue> TryRemove<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
- 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 ReadOnlyDictionaryView<K, V> AsReadOnlyView<K, V>(this IDictionary<K, V> dictionary)
- public static ReadOnlyDictionaryView<K, V, T> Convert<K, V, T>(this IReadOnlyDictionary<K, V> dictionary, Converter<V, T> mapper)
- public static Optional<T> ConvertValue<K, V, T>(this IDictionary<K, V> dictionary, K key, Converter<V, T> mapper)
- public static bool ConvertValue<K, V, T>(this IDictionary<K, V> dictionary, K key, Converter<V, T> mapper, out T value)
- public static void Deconstruct<K, V>(this KeyValuePair<K, V> pair, out K key, out V value)
- public static void ForEach<K, V>(this IDictionary<K, V> dictionary, Action<K, V> action)
- public static V GetOrAdd<K, V>(this Dictionary<K, V> dictionary, K key, V value)
- public static V GetOrAdd<K, V>(this Dictionary<K, V> dictionary, K key, Func<K, V> valueFactory)
- public static V GetOrInvoke<K, V>(this IDictionary<K, V> dictionary, K key, Func<V> defaultValue)
- public static Func<K, V> IndexerGetter<K, V>(this IReadOnlyDictionary<K, V> dictionary)
- public static Func<K, V> IndexerGetter<K, V>(this IDictionary<K, V> dictionary)
- public static Action<K, V> IndexerSetter<K, V>(this IDictionary<K, V> dictionary)
-
public static class Enumerator
-
public static class List
- public static ReadOnlyListView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyList<TInput> list, Converter<TInput, TOutput> converter)
- public static ReadOnlyListView<T> AsReadOnlyView<T>(this IList<T> list)
- public static ReadOnlyListView<I, O> Convert<I, O>(this IReadOnlyList<I> list, Converter<I, O> converter)
- public static void Insert<T>(this IList<T> list, Index index, T item)
- public static int InsertOrdered<T, TComparer>(this List<T> list, T item, TComparer comparer) where TComparer : IComparer<T>
- 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, Comparison<T> comparer)
- public static int InsertOrdered<T>(this IList<T> list, T item, method 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 static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, Converter<TInput, TOutput> mapper)
- public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, method mapper)
- public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, Func<int, TInput, TOutput> mapper)
- public static TOutput[] ToArray<TInput, TOutput>(this IList<TInput> input, method mapper)
- public static O[] ToArray<I, O>(this IList<I> input, Converter<I, O> mapper)
- public static O[] ToArray<I, O>(this IList<I> input, Func<int, I, O> mapper)
-
public struct ListSegment<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyList<T>, IReadOnlyCollection<T>
-
public struct ReadOnlyCollectionView<T> : IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, IEquatable<ReadOnlyCollectionView<T>>
-
public struct ReadOnlyCollectionView<I, O> : IReadOnlyCollection<O>, IEnumerable<O>, IEnumerable, IEquatable<ReadOnlyCollectionView<I, O>>
- 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 bool Equals(ReadOnlyCollectionView<TInput, TOutput> other)
- public IEnumerator<TOutput> GetEnumerator()
- public ReadOnlyCollectionView(IReadOnlyCollection<I> collection, Converter<I, O> mapper)
- public static bool op_Equality(ReadOnlyCollectionView<I, O> first, ReadOnlyCollectionView<I, O> second)
- public static bool op_Inequality(ReadOnlyCollectionView<I, O> first, ReadOnlyCollectionView<I, O> second)
- public bool Equals(ReadOnlyCollectionView<I, O> other)
- public IEnumerator<O> GetEnumerator()
-
public struct ReadOnlyDictionaryView<K, V> : IReadOnlyDictionary<K, V>, IEnumerable<KeyValuePair<K, V>>, IEnumerable, IReadOnlyCollection<KeyValuePair<K, V>>, IEquatable<ReadOnlyDictionaryView<K, V>>
- public int Count { get; }
- public V this[K key] { get; }
- public IEnumerable<K> Keys { get; }
- public IEnumerable<V> Values { get; }
- public ReadOnlyDictionaryView(IDictionary<K, V> dictionary)
- public static bool op_Equality(ReadOnlyDictionaryView<K, V> first, ReadOnlyDictionaryView<K, V> second)
- public static bool op_Inequality(ReadOnlyDictionaryView<K, V> first, ReadOnlyDictionaryView<K, V> second)
- public bool ContainsKey(K key)
- public bool Equals(ReadOnlyDictionaryView<K, V> other)
- public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
- public bool TryGetValue(K key, out V value)
-
public struct ReadOnlyDictionaryView<K, I, O> : IReadOnlyDictionary<K, O>, IEnumerable<KeyValuePair<K, O>>, IEnumerable, IReadOnlyCollection<KeyValuePair<K, O>>, IEquatable<ReadOnlyDictionaryView<K, I, O>>
- public TOutput this[TKey key] { get; }
- public IEnumerable<TKey> Keys { get; }
- public IEnumerable<TOutput> Values { get; }
- 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 bool ContainsKey(TKey key)
- public bool Equals(ReadOnlyDictionaryView<TKey, TInput, TOutput> other)
- public IEnumerator<KeyValuePair<TKey, TOutput>> GetEnumerator()
- public bool TryGetValue(TKey key, out TOutput value)
- public O this[K key] { get; }
- public IEnumerable<K> Keys { get; }
- public IEnumerable<O> Values { get; }
- public ReadOnlyDictionaryView(IReadOnlyDictionary<K, I> dictionary, Converter<I, O> mapper)
- public static bool op_Equality(ReadOnlyDictionaryView<K, I, O> first, ReadOnlyDictionaryView<K, I, O> second)
- public static bool op_Inequality(ReadOnlyDictionaryView<K, I, O> first, ReadOnlyDictionaryView<K, I, O> second)
- public bool ContainsKey(K key)
- public bool Equals(ReadOnlyDictionaryView<K, I, O> other)
- public IEnumerator<KeyValuePair<K, O>> GetEnumerator()
- public bool TryGetValue(K key, out O value)
-
public struct ReadOnlyListView<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IEquatable<ReadOnlyListView<T>>
-
public struct ReadOnlyListView<I, O> : IReadOnlyList<O>, IEnumerable<O>, IEnumerable, IReadOnlyCollection<O>, IEquatable<ReadOnlyListView<I, O>>
- public TOutput this[int index] { get; }
- 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 bool Equals(ReadOnlyListView<TInput, TOutput> other)
- public IEnumerator<TOutput> GetEnumerator()
- public O this[int index] { get; }
- public ReadOnlyListView(IReadOnlyList<I> list, Converter<I, O> mapper)
- public static bool op_Equality(ReadOnlyListView<I, O> first, ReadOnlyListView<I, O> second)
- public static bool op_Inequality(ReadOnlyListView<I, O> first, ReadOnlyListView<I, O> second)
- public bool Equals(ReadOnlyListView<I, O> other)
- public IEnumerator<O> GetEnumerator()
-
public static class Set
-
public static class Stack
DotNext.Collections.Specialized
-
public class ConcurrentTypeMap : ITypeMap, IReadOnlyTypeMap
-
public class ConcurrentTypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>
-
public static class InvocationList
-
public struct InvocationList<TDelegate> : IReadOnlyList<TDelegate>, IEnumerable<TDelegate>, IEnumerable, IReadOnlyCollection<TDelegate> where TDelegate : MulticastDelegate
-
public interface IReadOnlyTypeMap
-
public interface IReadOnlyTypeMap<TValue>
-
public interface ITypeMap : IReadOnlyTypeMap
-
public interface ITypeMap<TValue> : IReadOnlyTypeMap<TValue>
-
public struct SingletonList<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IList<T>, ICollection<T>, ITuple, IReadOnlySet<T>
-
public class TypeMap : ITypeMap, IReadOnlyTypeMap
-
public class TypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>
DotNext.ComponentModel.DataAnnotations
DotNext.Diagnostics
-
public struct Timestamp : IEquatable<Timestamp>, IComparable<Timestamp>, IComparisonOperators<Timestamp, Timestamp, bool>, IEqualityOperators<Timestamp, Timestamp, bool>, IAdditionOperators<Timestamp, TimeSpan, Timestamp>, ISubtractionOperators<Timestamp, TimeSpan, Timestamp>, IInterlockedOperations<Timestamp>
DotNext.Generic
DotNext.IO
-
public interface IFlushable
-
public struct StreamConsumer : IReadOnlySpanConsumer<byte>, ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<byte>, CancellationToken, ValueTask>>, IEquatable<StreamConsumer>, IFlushable
-
public static class StreamSource
-
public struct TextConsumer : IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFunctional<Func<ReadOnlyMemory<char>, CancellationToken, ValueTask>>, IFlushable, IEquatable<TextConsumer>
DotNext.IO.Hashing
DotNext.Net.Http
DotNext.Net.NetworkInformation
DotNext.Numerics
DotNext.Patterns
DotNext.Reflection
-
public static class CollectionType
-
public static class CustomAttribute
-
public static class Conversion<I, O>
-
public static class DisposableType
-
public static class EnumType
-
public static class MethodExtensions
-
public static class PropertyExtensions
-
public static class Method
-
public static class TaskType
-
public static class TypeExtensions
- public static MethodInfo Devirtualize(this Type type, MethodInfo abstractMethod)
- public static IEnumerable<Type> GetBaseTypes(this Type type, bool includeTopLevel = false, bool includeInterfaces = false)
- public static object GetDefaultValue(this Type type)
- 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)
- public static TypeCode GetTypeCode(this Type t)
- public static bool IsImmutable(this Type type)
- public static bool IsUnmanaged(this Type type)
DotNext.Resources
DotNext.Runtime
DotNext.Runtime.Caching
DotNext.Runtime.CompilerServices
DotNext.Runtime.ExceptionServices
DotNext.Runtime.InteropServices
-
public static class SafeBufferExtensions
-
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 int Compare(Void* first, Void* second, int length)
- public static int Compare(IntPtr first, IntPtr second, int length)
- public static void Copy(Void* source, Void* destination, long length)
- public static void Copy(IntPtr source, IntPtr destination, long length)
- public static bool Equals(Void* first, Void* second, int length)
- public static bool Equals(IntPtr first, IntPtr second, int length)
- public static long GetHashCode(IntPtr source, long length, long hash, Func<long, long, long> hashFunction, bool salted = true)
- public static long GetHashCode(Void* source, long length, long hash, Func<long, long, long> hashFunction, bool salted = true)
- public static int GetHashCode(IntPtr source, long length, int hash, Func<int, int, int> hashFunction, bool salted = true)
- public static int GetHashCode(Void* source, long length, int hash, Func<int, int, int> hashFunction, bool salted = true)
- public static int GetHashCode(IntPtr source, long length, bool salted = true)
- public static int GetHashCode(Void* source, long length, bool salted = true)
- public static T Read<T>(ref IntPtr source) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static long ReadFromStream(Stream source, IntPtr destination, long length)
- public static long ReadFromStream(Stream source, Void* destination, long length)
- public static Task<long> ReadFromStreamAsync(Stream source, IntPtr destination, long length)
- public static Task<long> ReadFromStreamAsync(Stream source, Void* destination, long length)
- public static T ReadUnaligned<T>(ref 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 WriteToSteam(IntPtr source, long length, Stream destination)
- public static void WriteToSteam(Void* source, long length, Stream destination)
- public static Task WriteToSteamAsync(IntPtr source, long length, Stream destination)
- public static Task WriteToSteamAsync(Void* source, long length, Stream destination)
- public static void WriteUnaligned<T>(ref IntPtr destination, T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
DotNext.Text
DotNext.Text.Json
DotNext.Threading
-
public static class Atomic
-
public struct Atomic<T> : IStrongBox, ICloneable where T : struct
-
public interface IInterlockedOperations<T>
-
public static class AsyncDelegate
- public static Task InvokeAsync<D>(this D delegate, Action<D> invoker, CancellationToken token = default) where D : MulticastDelegate
- public static Task InvokeAsync<E>(this EventHandler<E> handler, object sender, E args, CancellationToken token = default)
- public static Task InvokeAsync(this EventHandler handler, object sender, EventArgs args, CancellationToken token = default)
- public static Task InvokeAsync(this Action action, CancellationToken token = default)
- public static Task InvokeAsync<T>(this Action<T> action, T arg, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2>(this Action<T1, T2> action, T1 arg1, T2 arg2, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3>(this Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4, T5, T6>(this Action<T1, T2, T3, T4, T5, T6> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7>(this Action<T1, T2, T3, T4, T5, T6, T7> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Action<T1, T2, T3, T4, T5, T6, T7, T8> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, CancellationToken token = default)
-
public struct AtomicBoolean : IEquatable<bool>
- public bool Value { get; set; }
- public AtomicBoolean(bool value)
- public bool AccumulateAndGet(bool x, Func<bool, bool, bool> accumulator)
- public bool CompareAndSet(bool expected, bool update)
- public bool CompareExchange(bool update, bool expected)
- public bool Equals(bool other)
- public bool FalseToTrue()
- public bool GetAndAcummulate(bool x, Func<bool, bool, bool> accumulator)
- public bool GetAndNegate()
- public bool GetAndSet(bool update)
- public bool GetAndUpdate(Func<bool, bool> updater)
- public bool NegateAndGet()
- public bool SetAndGet(bool update)
- public bool TrueToFalse()
- public bool UpdateAndGet(Func<bool, bool> updater)
-
public static class AtomicDouble
- public static double AccumulateAndGet(this ref double value, double x, Func<double, double, double> accumulator)
- public static double AccumulateAndGet(this double[] array, long index, double x, Func<double, double, double> accumulator)
- public static double Add(this ref double value, double operand)
- public static double Add(this double[] array, long index, double operand)
- public static bool CompareAndSet(this ref double value, double expected, double update)
- public static bool CompareAndSet(this double[] array, long index, double expected, double update)
- public static long CompareExchange(this long[] array, long index, long update, long comparand)
- public static double DecrementAndGet(this ref double value)
- public static double DecrementAndGet(this double[] array, long index)
- public static double GetAndAccumulate(this ref double value, double x, Func<double, double, double> accumulator)
- public static double GetAndAccumulate(this double[] array, long index, double x, Func<double, double, double> accumulator)
- public static double GetAndSet(this ref double value, double update)
- public static double GetAndSet(this double[] array, long index, double update)
- public static double GetAndUpdate(this ref double value, Func<double, double> updater)
- public static double GetAndUpdate(this double[] array, long index, Func<double, double> updater)
- public static double IncrementAndGet(this ref double value)
- public static double IncrementAndGet(this double[] array, long index)
- public static double SetAndGet(this ref double value, double update)
- public static double SetAndGet(this double[] array, long index, double update)
- public static double UpdateAndGet(this ref double value, Func<double, double> updater)
- public static double UpdateAndGet(this double[] array, long index, Func<double, double> updater)
- public static double VolatileGet(this ref double value)
- public static double VolatileGet(this double[] array, long index)
- public static void VolatileSet(this ref double value, double newValue)
- public static void VolatileSet(this double[] array, long index, double value)
-
public static class AtomicFloat
- public static float AccumulateAndGet(this ref float value, float x, Func<float, float, float> accumulator)
- public static float AccumulateAndGet(this float[] array, long index, float x, Func<float, float, float> accumulator)
- public static float Add(this ref float value, float operand)
- public static float Add(this float[] array, long index, float operand)
- public static bool CompareAndSet(this ref float value, float expected, float update)
- public static bool CompareAndSet(this float[] array, long index, float expected, float update)
- public static float CompareExchange(this float[] array, long index, float update, float comparand)
- public static float DecrementAndGet(this ref float value)
- public static float DecrementAndGet(this float[] array, long index)
- public static float GetAndAccumulate(this ref float value, float x, Func<float, float, float> accumulator)
- public static float GetAndAccumulate(this float[] array, long index, float x, Func<float, float, float> accumulator)
- public static float GetAndSet(this ref float value, float update)
- public static float GetAndSet(this float[] array, long index, float update)
- public static float GetAndUpdate(this ref float value, Func<float, float> updater)
- public static float GetAndUpdate(this float[] array, long index, Func<float, float> updater)
- public static float IncrementAndGet(this ref float value)
- public static float IncrementAndGet(this float[] array, long index)
- public static float SetAndGet(this ref float value, float update)
- public static float SetAndGet(this float[] array, long index, float update)
- public static float UpdateAndGet(this ref float value, Func<float, float> updater)
- public static float UpdateAndGet(this float[] array, long index, Func<float, float> updater)
- public static float VolatileGet(this ref float value)
- public static float VolatileGet(this float[] array, long index)
- public static void VolatileSet(this ref float value, float newValue)
- public static void VolatileSet(this float[] array, long index, float value)
-
public static class AtomicInteger
- public static int AccumulateAndGet(this ref int value, int x, Func<int, int, int> accumulator)
- public static int AccumulateAndGet(this int[] array, long index, int x, Func<int, int, int> accumulator)
- public static int Add(this ref int value, int operand)
- public static int Add(this int[] array, long index, int operand)
- public static bool CompareAndSet(this ref int value, int expected, int update)
- public static bool CompareAndSet(this int[] array, long index, int expected, int update)
- public static int CompareExchange(this int[] array, long index, int update, int comparand)
- public static int DecrementAndGet(this ref int value)
- public static int DecrementAndGet(this int[] array, long index)
- public static int GetAndAccumulate(this ref int value, int x, Func<int, int, int> accumulator)
- public static int GetAndAccumulate(this int[] array, long index, int x, Func<int, int, int> accumulator)
- public static int GetAndSet(this ref int value, int update)
- public static int GetAndSet(this int[] array, long index, int update)
- public static int GetAndUpdate(this ref int value, Func<int, int> updater)
- public static int GetAndUpdate(this int[] array, long index, Func<int, int> updater)
- public static int IncrementAndGet(this ref int value)
- public static int IncrementAndGet(this int[] array, long index)
- public static int SetAndGet(this ref int value, int update)
- public static int SetAndGet(this int[] array, long index, int update)
- public static int UpdateAndGet(this ref int value, Func<int, int> updater)
- public static int UpdateAndGet(this int[] array, long index, Func<int, int> updater)
- public static int VolatileGet(this ref int value)
- public static int VolatileGet(this int[] array, long index)
- public static void VolatileSet(this ref int value, int newValue)
- public static void VolatileSet(this int[] array, long index, int value)
-
public static class AtomicLong
- public static long AccumulateAndGet(this ref long value, long x, Func<long, long, long> accumulator)
- public static long AccumulateAndGet(this long[] array, long index, long x, Func<long, long, long> accumulator)
- public static long Add(this ref long value, long operand)
- public static long Add(this long[] array, long index, long operand)
- public static bool CompareAndSet(this ref long value, long expected, long update)
- public static bool CompareAndSet(this long[] array, long index, long expected, long update)
- public static long CompareExchange(this long[] array, long index, long update, long comparand)
- public static long DecrementAndGet(this ref long value)
- public static long DecrementAndGet(this long[] array, long index)
- public static long GetAndAccumulate(this ref long value, long x, Func<long, long, long> accumulator)
- public static long GetAndAccumulate(this long[] array, long index, long x, Func<long, long, long> accumulator)
- public static long GetAndSet(this ref long value, long update)
- public static long GetAndSet(this long[] array, long index, long update)
- public static long GetAndUpdate(this ref long value, Func<long, long> updater)
- public static long GetAndUpdate(this long[] array, long index, Func<long, long> updater)
- public static long IncrementAndGet(this ref long value)
- public static long IncrementAndGet(this long[] array, long index)
- public static long SetAndGet(this ref long value, long update)
- public static long SetAndGet(this long[] array, long index, long update)
- public static long UpdateAndGet(this ref long value, Func<long, long> updater)
- public static long UpdateAndGet(this long[] array, long index, Func<long, long> updater)
- public static long VolatileGet(this ref long value)
- public static long VolatileGet(this long[] array, long index)
- public static void VolatileSet(this ref long value, long newValue)
- public static void VolatileSet(this long[] array, long index, long value)
-
public static class AtomicReference
- public static T AccumulateAndGet<T>(ref T value, T x, Func<T, T, T> accumulator)
- public static T AccumulateAndGet<T>(this T[] array, long index, T x, Func<T, T, T> accumulator)
- public static bool CompareAndSet<T>(ref T value, T expected, T update)
- public static bool CompareAndSet<T>(this T[] array, long index, T expected, T update)
- public static T CompareExchange<T>(this T[] array, long index, T update, T comparand)
- public static T GetAndAccumulate<T>(ref T value, T x, Func<T, T, T> accumulator)
- public static T GetAndAccumulate<T>(this T[] array, long index, T x, Func<T, T, T> accumulator)
- public static T GetAndSet<T>(this T[] array, long index, T update)
- public static T GetAndUpdate<T>(ref T value, Func<T, T> updater)
- public static T GetAndUpdate<T>(this T[] array, long index, Func<T, T> updater)
- public static T SetAndGet<T>(this T[] array, long index, T update)
- public static T UpdateAndGet<T>(ref T value, Func<T, T> updater)
- public static T UpdateAndGet<T>(this T[] array, long index, Func<T, T> updater)
- public static T VolatileGet<T>(this T[] array, long index)
- public static void VolatileSet<T>(this T[] array, long index, T element)
-
public struct AtomicReference<T> : IEquatable<T>
- public T Value { get; set; }
- public AtomicReference(T value)
- public T AccumulateAndGet(T x, Func<T, T, T> 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 GetAndSet(T update)
- public T GetAndUpdate(Func<T, T> updater)
- public T SetAndGet(T update)
- public T SetIfNull<G>() where G : T
- public T SetIfNull(Func<T> supplier)
- public T UpdateAndGet(Func<T, T> updater)
-
public class ConcurrentObjectPool<T>
-
public struct Lock : IDisposable, IEquatable<Lock>
-
public static class LockAcquisition
-
public struct ReaderWriterSpinLock
-
public static class ThreadPoolWorkItemFactory
-
public struct Timeout
DotNext.Threading.Tasks
-
public static class Conversion
- public static DynamicTaskAwaitable AsDynamic(this Task task)
- public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task) where TInput : TOutput
- public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task, Converter<TInput, TOutput> converter)
- public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task, Converter<TInput, Task<TOutput>> converter)
- public static SuspendedExceptionTaskAwaitable SuspendException(this Task task, Predicate<Exception> filter = null)
- public static SuspendedExceptionTaskAwaitable SuspendException(this ValueTask task, Predicate<Exception> filter = null)
- public static Task<T?> ToNullable<T>(this Task<T> task) where T : struct
- public static Task<O> Convert<I, O>(this Task<I> task, Converter<I, O> converter)
- public static Task<O> Convert<I, O>(this Task<I> task, Converter<I, Task<O>> converter)
-
public struct DynamicTaskAwaitable
-
public static class Synchronization
- public static Result<TResult> GetResult<TResult>(this Task<TResult> task, TimeSpan timeout)
- public static Result<TResult> GetResult<TResult>(this Task<TResult> task, CancellationToken token)
- public static Result<object> GetResult(this Task task, CancellationToken token)
- public static Result<object> GetResult(this Task task, TimeSpan timeout)
- public static Result<TResult>? TryGetResult<TResult>(this Task<TResult> task)
- public static Task<ValueTuple<Result<T1>, Result<T2>>> WhenAll<T1, T2>(Task<T1> task1, Task<T2> task2)
- public static Task<ValueTuple<Result<T1>, Result<T2>, Result<T3>>> WhenAll<T1, T2, T3>(Task<T1> task1, Task<T2> task2, Task<T3> task3)
- public static Task<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>>> WhenAll<T1, T2, T3, T4>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4)
- public static Task<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>, Result<T5>>> WhenAll<T1, T2, T3, T4, T5>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4, Task<T5> task5)
- public static ValueTask WhenAll(ValueTask task1, ValueTask task2)
- public static ValueTask<ValueTuple<Result<T1>, Result<T2>>> WhenAll<T1, T2>(ValueTask<T1> task1, ValueTask<T2> task2)
- public static ValueTask WhenAll(ValueTask task1, ValueTask task2, ValueTask task3)
- public static ValueTask<ValueTuple<Result<T1>, Result<T2>, Result<T3>>> WhenAll<T1, T2, T3>(ValueTask<T1> task1, ValueTask<T2> task2, ValueTask<T3> task3)
- public static ValueTask WhenAll(ValueTask task1, ValueTask task2, ValueTask task3, ValueTask task4)
- public static ValueTask<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>>> WhenAll<T1, T2, T3, T4>(ValueTask<T1> task1, ValueTask<T2> task2, ValueTask<T3> task3, ValueTask<T4> task4)
- public static ValueTask WhenAll(ValueTask task1, ValueTask task2, ValueTask task3, ValueTask task4, ValueTask task5)
- public static ValueTask<ValueTuple<Result<T1>, Result<T2>, Result<T3>, Result<T4>, Result<T5>>> WhenAll<T1, T2, T3, T4, T5>(ValueTask<T1> task1, ValueTask<T2> task2, ValueTask<T3> task3, ValueTask<T4> task4, ValueTask<T5> task5)
- public static R GetResult<R>(this Task<R> task, TimeSpan timeout)
- public static R GetResult<R>(this Task<R> task, CancellationToken token)
- public static Task<ValueTuple<T1, T2>> WhenAll<T1, T2>(Task<T1> task1, Task<T2> task2)
- public static Task<ValueTuple<T1, T2, T3>> WhenAll<T1, T2, T3>(Task<T1> task1, Task<T2> task2, Task<T3> task3)
- public static Task<ValueTuple<T1, T2, T3, T4>> WhenAll<T1, T2, T3, T4>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4)
- public static Task<ValueTuple<T1, T2, T3, T4, T5>> WhenAll<T1, T2, T3, T4, T5>(Task<T1> task1, Task<T2> task2, Task<T3> task3, Task<T4> task4, Task<T5> task5)
DotNext.VariantType
-
public interface IVariant : IDynamicMetaObjectProvider, IOptional
-
public struct Variant<T1, T2> : IEquatable<Variant<T1, T2>>, IVariant, IDynamicMetaObjectProvider, IOptional
- public Optional<T1> First { get; }
- public bool IsPresent { get; }
- public Optional<T2> Second { get; }
- public Variant(T1 value)
- public Variant(T2 value)
- public static bool op_Equality(Variant<T1, T2> first, Variant<T1, T2> second)
- public static T1 op_Explicit(Variant<T1, T2> var)
- public static T2 op_Explicit(Variant<T1, T2> var)
- public static bool op_False(Variant<T1, T2> variant)
- public static Variant<T1, T2> op_Implicit(T1 value)
- public static Variant<T1, T2> op_Implicit(T2 value)
- public static bool op_Inequality(Variant<T1, T2> first, Variant<T1, T2> second)
- public static bool op_True(Variant<T1, T2> variant)
- public Optional<R> Convert<R>(Converter<T1, R> mapper1, Converter<T2, R> mapper2)
- public Variant<U1, U2> Convert<U1, U2>(Converter<T1, U1> mapper1, Converter<T2, U2> mapper2)
- public bool Equals<V>(V other) where V : IVariant
- public Variant<T2, T1> Permute()
-
public struct Variant<T1, T2, T3> : IVariant, IDynamicMetaObjectProvider, IOptional, IEquatable<Variant<T1, T2, T3>>
- public bool IsPresent { get; }
- public Variant(T1 value)
- public Variant(T2 value)
- public Variant(T3 value)
- public static bool op_Equality(Variant<T1, T2, T3> first, Variant<T1, T2, T3> second)
- public static T1 op_Explicit(Variant<T1, T2, T3> var)
- public static T2 op_Explicit(Variant<T1, T2, T3> var)
- public static T3 op_Explicit(Variant<T1, T2, T3> var)
- public static bool op_False(Variant<T1, T2, T3> variant)
- public static Variant<T1, T2, T3> op_Implicit(T1 value)
- public static Variant<T1, T2, T3> op_Implicit(T2 value)
- public static Variant<T1, T2, T3> op_Implicit(T3 value)
- public static Variant<T1, T2, T3> op_Implicit(Variant<T1, T2> variant)
- public static bool op_Inequality(Variant<T1, T2, T3> first, Variant<T1, T2, T3> second)
- public static bool op_True(Variant<T1, T2, T3> variant)
- public bool Equals<V>(V other) where V : IVariant
- public Variant<T3, T1, T2> Permute()
-
public struct Variant<T1, T2, T3, T4> : IVariant, IDynamicMetaObjectProvider, IOptional, IEquatable<Variant<T1, T2, T3, T4>>
- public bool IsPresent { get; }
- public Variant(T1 value)
- public Variant(T2 value)
- public Variant(T3 value)
- public Variant(T4 value)
- public static bool op_Equality(Variant<T1, T2, T3, T4> first, Variant<T1, T2, T3, T4> second)
- public static T1 op_Explicit(Variant<T1, T2, T3, T4> var)
- public static T2 op_Explicit(Variant<T1, T2, T3, T4> var)
- public static T3 op_Explicit(Variant<T1, T2, T3, T4> var)
- public static T4 op_Explicit(Variant<T1, T2, T3, T4> var)
- public static bool op_False(Variant<T1, T2, T3, T4> variant)
- public static Variant<T1, T2, T3, T4> op_Implicit(T1 value)
- public static Variant<T1, T2, T3, T4> op_Implicit(T2 value)
- public static Variant<T1, T2, T3, T4> op_Implicit(T3 value)
- public static Variant<T1, T2, T3, T4> op_Implicit(T4 value)
- public static Variant<T1, T2, T3, T4> op_Implicit(Variant<T1, T2, T3> variant)
- public static Variant<T1, T2, T3, T4> op_Implicit(Variant<T1, T2> variant)
- public static bool op_Inequality(Variant<T1, T2, T3, T4> first, Variant<T1, T2, T3, T4> second)
- public static bool op_True(Variant<T1, T2, T3, T4> variant)
- public bool Equals<V>(V other) where V : IVariant
- public Variant<T4, T1, T2, T3> Permute()