DotNext by Roman Sakno

API Diff between 1.2.9 and 4.1.0

864 Additions 519 Removals

DotNext

public struct Activator<T> : ISupplier<T>
public sealed class BitwiseComparer<T> : IEqualityComparer<T>, IComparer<T> where T : struct
- public static int Compare<TOther>(ref T first, ref TOther second) where TOther : struct
- public static bool Equals<TOther>(ref T first, ref TOther second) where TOther : struct
- public static int GetHashCode(ref T value, bool salted = true)
- public static int GetHashCode(ref T value, int hash, Func<int, int, int> hashFunction, bool salted = true)
- public static int GetHashCode<THashFunction>(ref T value, bool salted = true) where THashFunction : struct, IConsumer<int>, ISupplier<int>
- public static int Compare<G>(T first, G second) where G : struct
- public static bool Equals<G>(T first, G second) where G : struct
- public static int GetHashCode(T value, bool salted = true)
- public static int GetHashCode(T value, int hash, Func<int, int, int> hashFunction, bool salted = true)
- public static int GetHashCode(T value, int hash, ref ValueFunc hashFunction, bool salted = true)
public static class Comparable
- public static bool Between<T>(this T value, T left, T right, BoundType boundType = 0) where T : IComparable<T>
- public static T Clamp<T>(this T value, T min, T max) where T : IComparable<T>
- public static T Max<T>(T first, T second, Comparison<T> comparer)
- public static T Max<T>(T first, T second, IComparer<T> comparer)
- public static T Max<T>(this T first, T second) where T : IComparable<T>
- public static T Min<T>(T first, T second, Comparison<T> comparer)
- public static T Min<T>(T first, T second, IComparer<T> comparer)
- public static T Min<T>(this T first, T second) where T : IComparable<T>
public static class Comparison
- public static T Clamp<T>(this T value, T min, T max) where T : IComparable<T>
- public static bool IsBetween<T>(this T value, T left, T right, BoundType boundType = 0) where T : IComparable<T>
- public static ValueFunc<T, T, int> AsValueFunc<T>(this Comparison<T> comparison, bool wrap = false)
public struct Consumer<T> : IConsumer<T>
public struct ConsumerClosure<TContext, T> : IConsumer<T>
public static class Converter
- public static 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 ValueFunc<I, O> AsValueFunc<I, O>(this Converter<I, O> converter, bool wrap = false)
- 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 Result<O> TryInvoke<I, O>(this Converter<I, O> converter, I input)
public static class DelegateHelpers
- 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 Func<R> Bind<T, R>(this Func<T, R> func, T obj)
- public static Func<T2, R> Bind<T1, T2, R>(this Func<T1, T2, R> func, T1 obj)
- public static Func<T2, T3, TResult> Bind<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> func, T1 obj)
- public static Func<T2, T3, R> Bind<T1, T2, T3, R>(this Func<T1, T2, T3, R> func, 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 Func<T2, T3, T4, R> Bind<T1, T2, T3, T4, R>(this Func<T1, T2, T3, T4, R> func, 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 Func<T2, T3, T4, T5, R> Bind<T1, T2, T3, T4, T5, R>(this Func<T1, T2, T3, T4, T5, R> func, T1 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 D ChangeType<D>(this Delegate d) where D : Delegate
- public static EventHandler<O> Contravariant<I, O>(this EventHandler handler) where O : I
- public static Func<object, D> CreateClosedDelegateFactory<D>(Expression<D> expression) where D : Delegate
- public static D CreateDelegate<D>(this MethodInfo method, object target = null) where D : Delegate
- public static D CreateOpenDelegate<D>(Expression<D> expression) where D : Delegate
- 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 Func<T, R> Unbind<T, R>(this Func<R> func)
- public static Func<G, T, R> Unbind<G, T, R>(this Func<T, R> func)
- public static Action<G, T> Unbind<G, T>(this Action<T> action)
- public static Func<G, T1, T2, R> Unbind<G, T1, T2, R>(this Func<T1, T2, R> func)
- public static Action<G, T1, T2> Unbind<G, T1, T2>(this Action<T1, T2> action)
- public static Func<G, T1, T2, T3, R> Unbind<G, T1, T2, T3, R>(this Func<T1, T2, T3, R> func)
- public static Action<G, T1, T2, T3> Unbind<G, T1, T2, T3>(this Action<T1, T2, T3> action)
- public static Func<G, T1, T2, T3, T4, R> Unbind<G, T1, T2, T3, T4, R>(this Func<T1, T2, T3, T4, R> func)
- public static Action<G, T1, T2, T3, T4> Unbind<G, T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action)
- public static Func<G, T1, T2, T3, T4, T5, R> Unbind<G, T1, T2, T3, T4, T5, R>(this Func<T1, T2, T3, T4, T5, R> func)
- public static Action<G, T1, T2, T3, T4, T5> Unbind<G, T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action)
public struct DelegatingConsumer<T> : IConsumer<T>
public struct DelegatingSupplier<TResult> : ISupplier<TResult>, IEquatable<DelegatingSupplier<TResult>>
public struct DelegatingSupplier<T, TResult> : ISupplier<T, TResult>, IEquatable<DelegatingSupplier<T, TResult>>
public struct DelegatingSupplier<T1, T2, TResult> : ISupplier<T1, T2, TResult>, IEquatable<DelegatingSupplier<T1, T2, TResult>>
public abstract class Disposable : IDisposable
- protected Task DisposedTask { get; }
- public static ValueTask DisposeAsync(IEnumerable<IAsyncDisposable> objects)
- public static ValueTask DisposeAsync(IAsyncDisposable[] objects)
- protected static void QueueDispose(IDisposable resource)
- protected ValueTask DisposeAsync()
- protected virtual ValueTask DisposeAsyncCore()
- protected Task<T> GetDisposedTask<T>()
- protected bool TrySetDisposedException<T>(TaskCompletionSource<T> source)
- protected bool TrySetDisposedException(TaskCompletionSource source)
public struct Enum<E> : IEquatable<E>, IComparable<E>, IFormattable, IEquatable<Enum<E>>, ISerializable where E : struct, Enum
- public static readonly Enum<E> MaxValue
- public static readonly Enum<E> MinValue
- public static IReadOnlyList<Enum<E>> Members { get; }
- public static Type UnderlyingType { get; }
- public static TypeCode UnderlyingTypeCode { get; }
- public string Name { get; }
- public E Value { get; }
- public static Enum<E> GetMember(E value)
- public static Enum<E> GetMember(string name)
- public static bool IsDefined(E value)
- public static bool IsDefined(string name)
- public static bool op_Equality(Enum<E> first, Enum<E> second)
- public static E op_Implicit(ref Enum en)
- public static bool op_Inequality(Enum<E> first, Enum<E> second)
- public static bool TryGetMember(E value, out Enum member)
- public static bool TryGetMember(string name, out Enum member)
- public int CompareTo(E other)
- public bool Equals(E other)
- public bool Equals(Enum<E> other)
- public bool HasFlag(E flag)
public static class EnumConverter
- public static TypeCode GetTypeCode<TEnum>() where TEnum : struct, Enum
public static class EnumerableTuple
- public static EnumerableTuple<T, ValueTuple<T>> AsEnumerable<T>(this ValueTuple<T> tuple)
- public static EnumerableTuple<T, Tuple<T>> AsEnumerable<T>(this Tuple<T> tuple)
- public static EnumerableTuple<T, ValueTuple<T, T>> AsEnumerable<T>(this ValueTuple<T, T> tuple)
- public static EnumerableTuple<T, Tuple<T, T>> AsEnumerable<T>(this Tuple<T, T> tuple)
- public static EnumerableTuple<T, ValueTuple<T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T> tuple)
- public static EnumerableTuple<T, Tuple<T, T, T>> AsEnumerable<T>(this Tuple<T, T, T> tuple)
- public static EnumerableTuple<T, ValueTuple<T, T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T, T> tuple)
- public static EnumerableTuple<T, Tuple<T, T, T, T>> AsEnumerable<T>(this Tuple<T, T, T, T> tuple)
- public static EnumerableTuple<T, ValueTuple<T, T, T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T, T, T> tuple)
- public static EnumerableTuple<T, Tuple<T, T, T, T, T>> AsEnumerable<T>(this Tuple<T, T, T, T, T> tuple)
- public static EnumerableTuple<T, ValueTuple<T, T, T, T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T, T, T, T> tuple)
- public static EnumerableTuple<T, Tuple<T, T, T, T, T, T>> AsEnumerable<T>(this Tuple<T, T, T, T, T, T> tuple)
- public static EnumerableTuple<T, ValueTuple<T, T, T, T, T, T, T>> AsEnumerable<T>(this ValueTuple<T, T, T, T, T, T, T> tuple)
- public static EnumerableTuple<T, Tuple<T, T, T, T, T, T, T>> AsEnumerable<T>(this Tuple<T, T, T, T, T, T, T> tuple)
public struct EnumerableTuple<I, T> : IReadOnlyList, IEnumerable, IEnumerable, IReadOnlyCollection where T : IStructuralEquatable, IStructuralComparable
- public struct Enumerator<I, T> : IEnumerator, IEnumerator, IDisposable where T : IStructuralEquatable, IStructuralComparable
- public int Count { get; }
- public I this[int index] { get; }
- public Enumerator<I, T> GetEnumerator()
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<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 static Result<R> TryInvoke<R>(this Func<R> function)
- public static Result<R> TryInvoke<T, R>(this Func<T, R> function, T arg)
- public static Result<R> TryInvoke<T1, T2, R>(this Func<T1, T2, R> function, T1 arg1, T2 arg2)
- public static Result<R> TryInvoke<T1, T2, T3, R>(this Func<T1, T2, T3, R> function, T1 arg1, T2 arg2, T3 arg3)
- public static Result<R> TryInvoke<T1, T2, T3, T4, R>(this Func<T1, T2, T3, T4, R> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
- public static Result<R> TryInvoke<T1, T2, T3, T4, T5, R>(this Func<T1, T2, T3, T4, T5, R> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
- public static Result<R> TryInvoke<T1, T2, T3, T4, T5, T6, R>(this Func<T1, T2, T3, T4, T5, T6, R> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
- public static Result<R> TryInvoke<T1, T2, T3, T4, T5, T6, T7, R>(this Func<T1, T2, T3, T4, T5, T6, T7, R> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
- public static Result<R> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, R>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, R> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
- public static Result<R> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> function, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
- public static Result<R> TryInvoke<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> 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>
public interface IOptionMonad<T>
public interface IOptionMonad<T, TSelf> : IOptionMonad<T> where TSelf : struct, IOptionMonad<T, TSelf>
public interface IResultMonad<T, TError> : IOptionMonad<T>
public interface IResultMonad<T, TError, TSelf> : IResultMonad<T, TError>, IOptionMonad<T>, IOptionMonad<T, TSelf> where TSelf : struct, IResultMonad<T, TError, TSelf>
public interface ISupplier<TResult>
public interface ISupplier<T, TResult>
public interface ISupplier<T1, T2, TResult>
public interface ICallable
- bool IsEmpty { get; }
- object Target { get; }
- object DynamicInvoke(object[] args)
public interface ICallable<D> : ICallable where D : Delegate
- D ToDelegate()
public static class ObjectExtensions
- public static T As<T>(this T obj)
- 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 void Decompose<T, R1, R2>(this T obj, ref ValueFunc decomposer1, ref ValueFunc 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 ValueTuple<R1, R2> Decompose<T, R1, R2>(this T obj, ref ValueFunc decomposer1, ref ValueFunc decomposer2)
public static class OneDimensionalArray
- public static int BitwiseHashCode<T>(this T[] array, int hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T, THashFunction>(this T[] array, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where THashFunction : struct, IConsumer<int>, ISupplier<int>
- public static long BitwiseHashCode64<T>(this T[] array, long hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static long BitwiseHashCode64<T, THashFunction>(this T[] array, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where THashFunction : struct, IConsumer<long>, ISupplier<long>
- public static T[] Concat<T>(this T[] left, T[] right, long startIndex)
- public static void ForEach<T>(this T[] array, RefAction<T, IntPtr> action)
- public static void ForEach<T, TArg>(this T[] array, method action, TArg arg)
- public static void ForEach<T>(this T[] array, ref ValueRefAction action)
- public static void ForEach<T>(this T[] array, RefAction<T, long> action)
- public static T[] Insert<T>(this T[] array, T element, Index index)
- public static bool IsNullOrEmpty(this Array array)
- public static bool IsNullOrEmpty<T>(this T[] array)
- public static T[] RemoveAll<T>(this T[] array, ref ValueFunc match, out long count)
- public static T[] RemoveAll<T>(this T[] array, method match, out long count)
- public static T[] RemoveAll<T>(this T[] array, ref ValueFunc match, ref ValueAction callback)
- public static T[] RemoveAll<T>(this T[] array, method match, Action<T> callback)
- public static T[] RemoveAt<T>(this T[] array, Index index)
- public static bool SequenceEqual(this object[] first, object[] second, bool parallel = false)
- public static bool SequenceEqual(this object[] first, object[] second)
- public static ArraySegment<T> Slice<T>(this T[] input, Range range)
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 T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T, TException>(ref Optional optional) where T : struct where TException : Exception
- public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(ref Optional optional, Func<Exception> exceptionFactory) where T : struct
- public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(ref Optional optional, method exceptionFactory) where T : struct
- public static Task<Optional<O>> Convert<I, O>(this Task<Optional> task, Converter<I, O> converter)
- public static Optional<T> None<T>()
- public static Optional<T> Null<T>()
- 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> : IEquatable<Optional<T>>, IEquatable<T>, IStructuralEquatable, ISerializable
- public static Optional<T> None { get; }
- public bool HasValue { get; }
- public bool IsNull { get; }
- public bool IsUndefined { get; }
- public static Optional<T> Empty { get; }
- public bool IsPresent { get; }
- public static bool IsValueDefined(T value)
- public Optional<object> Box()
- public Optional<TResult> Convert<TResult>(Converter<T, TResult> mapper)
- public Optional<TResult> Convert<TResult>(method mapper)
- public Optional<TResult> Convert<TResult>(Converter<T, Optional<TResult>> mapper)
- public Optional<TResult> Convert<TResult>(method mapper)
- public Optional Convert(ref ValueFunc mapper)
- public Optional Convert(Converter<T, U> mapper)
- public Optional Convert(ref ValueFunc mapper)
- public Optional Convert(Converter<T, Optional> mapper)
- public Optional<T> If(ref ValueFunc condition)
- public Optional<T> If(method condition)
- public T OrInvoke(ref ValueFunc defaultFunc)
- public T OrInvoke(method defaultFunc)
- public T OrThrow(Func<Exception> exceptionFactory)
- public T OrThrow(method exceptionFactory)
- public T OrThrow<E>(ref ValueFunc exceptionFactory) where E : Exception
- public T OrThrow<E>(Func<E> exceptionFactory) where E : Exception
- public bool TryGet(out T value, out bool isNull)
public static class Predicate
- public static ValueFunc<T, bool> AsValueFunc<T>(this Predicate<T> predicate, bool wrap = false)
- public static Predicate<object> IsTypeOf<T>()
public static class RandomExtensions
- public static T Next<T>(this Random random) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static T Next<T>(this RandomNumberGenerator random) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static string NextString(this Random random, char[] allowedChars, int length)
- public static string NextString(this RandomNumberGenerator random, char[] allowedChars, int length)
public static class Result
- public static Result<T> FromException<T>(Exception e)
- public static Result<T> FromValue<T>(T value)
- public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T>(ref Result result)
- public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReference<T, TError>(ref Result result) where TError : struct, Enum
- public static T? OrNull<T, TError>(this ref Result result) where T : struct where TError : struct, Enum
public struct Result<T> : ISerializable
- public static Result<T> FromOptional(ref Optional optional)
- public static Result<T> op_Explicit(ref Optional optional)
- public Result<object> Box()
- public Result<TResult> Convert<TResult>(Converter<T, TResult> converter)
- public Result<TResult> Convert<TResult>(method converter)
- public Result Convert(ref ValueFunc converter)
- public Result Convert(Converter<T, U> converter)
- public T OrInvoke(ref ValueFunc defaultFunc)
- public T OrInvoke(method defaultFunc)
- public T OrInvoke(ref ValueFunc defaultFunc)
- public T OrInvoke(method defaultFunc)
- public Optional<T> TryGet()
public struct Result<T, TError> : IResultMonad<T, TError, Result<T, TError>>, IResultMonad<T, TError>, IOptionMonad<T>, IOptionMonad<T, Result<T, TError>> where TError : struct, Enum
public static class ServiceProviderFactory
public static class Sequence
- public static IEnumerable<T> Append<T>(this IEnumerable<T> collection, T[] items)
- public static bool ElementAt<T>(this IEnumerable<T> collection, int index, out T element)
- public static Optional<T> FirstOrEmpty<T>(this IEnumerable<T> seq)
- public static T? FirstOrNull<T>(this IEnumerable<T> seq) where T : struct
- public static void ForEach<T>(this IEnumerable<T> collection, Action<T> action)
- public static void ForEach<T>(this IEnumerable<T> collection, ref ValueAction action)
- public static IEnumerable<T> Prepend<T>(this IEnumerable<T> collection, T[] items)
- public static int SequenceHashCode(this IEnumerable<object> sequence, bool salted = true)
- public static IEnumerable<T> Singleton<T>(T item)
- public static bool Skip<T>(this IEnumerator<T> enumerator, int count)
- public static IEnumerable<T> SkipNulls<T>(this IEnumerable<T> collection)
- public static string ToString<T>(this IEnumerable<T> collection, string delimiter, string ifEmpty = "")
public static class Span
- public static Span<byte> AsBytes<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static Span<byte> AsBytes<T>(T* pointer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static ReadOnlySpan<byte> AsReadOnlyBytes<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T>(this Span<T> span, int hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T, THashFunction>(this Span<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where THashFunction : struct, IConsumer<int>, ISupplier<int>
- public static int BitwiseHashCode<T>(this ReadOnlySpan<T> span, int hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static int BitwiseHashCode<T, THashFunction>(this ReadOnlySpan<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where THashFunction : struct, IConsumer<int>, ISupplier<int>
- public static long BitwiseHashCode64<T>(this Span<T> span, long hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static long BitwiseHashCode64<T, THashFunction>(this Span<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where THashFunction : struct, IConsumer<long>, ISupplier<long>
- public static long BitwiseHashCode64<T>(this ReadOnlySpan<T> span, long hash, ref ValueFunc hashFunction, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static long BitwiseHashCode64<T, THashFunction>(this ReadOnlySpan<T> span, bool salted = true) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType) where THashFunction : struct, IConsumer<long>, ISupplier<long>
- public static MemoryOwner<T> Concat<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second, MemoryAllocator<T> allocator = null)
- public static MemoryOwner<T> Concat<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second, ReadOnlySpan<T> third, MemoryAllocator<T> allocator = null)
- public static MemoryOwner<T> Copy<T>(this ReadOnlySpan<T> span, MemoryAllocator<T> allocator = null)
- public static void CopyTo<T>(this ReadOnlySpan<T> source, Span<T> destination, out int writtenCount)
- public static void CopyTo<T>(this Span<T> source, Span<T> destination, out int writtenCount)
- public static Optional<T> FirstOrEmpty<T>(this ReadOnlySpan<T> span)
- public static void ForEach<T>(this Span<T> span, ref ValueRefAction action)
- public static void ForEach<T, TArg>(this Span<T> span, method action, TArg arg)
- public static int FromHex(this ReadOnlySpan<char> chars, Span<byte> output)
- public static byte[] FromHex(this ReadOnlySpan<char> chars)
- public static int IndexOf<T>(this ReadOnlySpan<T> span, T value, int startIndex, ref ValueFunc comparer)
- public static int IndexOf<T>(this ReadOnlySpan<T> span, T value, int startIndex, method comparer)
- public static void Initialize<T>(this Span<T> span)
- public static Optional<T> PeekRandom<T>(this ReadOnlySpan<T> span, Random random)
- public static void Shuffle<T>(this Span<T> span, Random random)
- public static void Sort<T>(this Span<T> span, method comparison)
- public static int ToHex(this ReadOnlySpan<byte> bytes, Span<char> output, bool lowercased = false)
- public static string ToHex(this ReadOnlySpan<byte> bytes, bool lowercased = false)
- public static void Sort<T>(this Span<T> span, IComparer<T> comparison = null)
- public static void Sort<T>(this Span<T> span, ref ValueFunc comparison)
- public static void Sort<T>(this Span<T> span, Comparison<T> comparison)
public static class StringExtensions
- public static MemoryTemplate<char> AsTemplate(this string template, string placeholder)
- public static MemoryTemplate<char> AsTemplate(this string template, char placeholder)
- public static Char& modreq(System.Runtime.InteropServices.InAttribute) GetRawData(this string str)
- public static bool IsNullOrEmpty(this StringBuilder builder)
- public static bool IsEqualIgnoreCase(this string strA, string strB)
- public static string Substring(this string str, Range range)
- public static ChunkSequence<char> Split(this string str, int chunkSize)
public struct Supplier<TResult> : ISupplier<TResult>
public struct Supplier<T, TResult> : ISupplier<T, TResult>
public struct Supplier<T1, T2, TResult> : ISupplier<T1, T2, TResult>
public struct SupplierClosure<TContext, TResult> : ISupplier<TResult>
public struct SupplierClosure<TContext, T, TResult> : ISupplier<T, TResult>
public struct SupplierClosure<TContext, T1, T2, TResult> : ISupplier<T1, T2, TResult>
public static class TupleExtensions
public sealed class UndefinedResultException<TError> : Exception where TError : struct, Enum
public struct UserDataSlot<V> : IEquatable<UserDataSlot<V>>
- public static UserDataSlot<TValue> Allocate()
- public static bool op_Equality(UserDataSlot<TValue> first, UserDataSlot<TValue> second)
- public static bool op_Inequality(UserDataSlot<TValue> first, UserDataSlot<TValue> second)
- public bool Equals(UserDataSlot<TValue> other)
- public static UserDataSlot<V> Allocate()
- public static bool op_Equality(UserDataSlot<V> first, UserDataSlot<V> second)
- public static bool op_Inequality(UserDataSlot<V> first, UserDataSlot<V> second)
- public bool Equals(UserDataSlot<V> other)
public struct UserDataStorage
- public interface IContainer
- 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 B GetOrSet<B, D>(UserDataSlot slot) where D : B
- public V GetOrSet<V>(UserDataSlot<V> slot, Func<V> valueFactory)
- public V GetOrSet<T, V>(UserDataSlot<V> slot, T arg, Func<T, V> valueFactory)
- public V GetOrSet<T1, T2, V>(UserDataSlot<V> slot, T1 arg1, T2 arg2, Func<T1, T2, V> valueFactory)
- public V GetOrSet<V>(UserDataSlot<V> slot, ref ValueFunc valueFactory)
- public V GetOrSet<T, V>(UserDataSlot<V> slot, T arg, ref ValueFunc valueFactory)
- public V GetOrSet<T1, T2, V>(UserDataSlot<V> slot, T1 arg1, T2 arg2, ref ValueFunc 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>
public struct ValueAction : ICallable<Action>, ICallable, IEquatable<ValueAction>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueAction(MethodInfo method)
- public ValueAction(Action action, bool wrap = false)
- public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueAction first, ref ValueAction second)
- public static Action op_Explicit(ref ValueAction pointer)
- public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
- public bool Equals(ValueAction other)
- public void Invoke()
- public Action ToDelegate()
public struct ValueAction<T> : ICallable<Action<T>>, ICallable, IEquatable<ValueAction<T>>, IConsumer<T>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueAction(MethodInfo method)
- public ValueAction(Action<T> action, bool wrap = false)
- public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueAction first, ref ValueAction second)
- public static Action<T> op_Explicit(ref ValueAction pointer)
- public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
- public bool Equals(ValueAction<T> other)
- public void Invoke(T arg)
- public Action<T> ToDelegate()
public struct ValueAction<T1, T2> : ICallable<Action<T1, T2>>, ICallable, IEquatable<ValueAction<T1, T2>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueAction(MethodInfo method)
- public ValueAction(Action<T1, T2> action, bool wrap = false)
- public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueAction first, ref ValueAction second)
- public static Action<T1, T2> op_Explicit(ref ValueAction pointer)
- public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
- public bool Equals(ValueAction<T1, T2> other)
- public void Invoke(T1 arg1, T2 arg2)
- public Action<T1, T2> ToDelegate()
public struct ValueAction<T1, T2, T3> : ICallable<Action<T1, T2, T3>>, ICallable, IEquatable<ValueAction<T1, T2, T3>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueAction(MethodInfo method)
- public ValueAction(Action<T1, T2, T3> action, bool wrap = false)
- public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueAction first, ref ValueAction second)
- public static Action<T1, T2, T3> op_Explicit(ref ValueAction pointer)
- public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
- public bool Equals(ValueAction<T1, T2, T3> other)
- public void Invoke(T1 arg1, T2 arg2, T3 arg3)
- public Action<T1, T2, T3> ToDelegate()
public struct ValueAction<T1, T2, T3, T4> : ICallable<Action<T1, T2, T3, T4>>, ICallable, IEquatable<ValueAction<T1, T2, T3, T4>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueAction(MethodInfo method)
- public ValueAction(Action<T1, T2, T3, T4> action, bool wrap = false)
- public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueAction first, ref ValueAction second)
- public static Action<T1, T2, T3, T4> op_Explicit(ref ValueAction pointer)
- public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
- public bool Equals(ValueAction<T1, T2, T3, T4> other)
- public void Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
- public Action<T1, T2, T3, T4> ToDelegate()
public struct ValueAction<T1, T2, T3, T4, T5> : ICallable<Action<T1, T2, T3, T4, T5>>, ICallable, IEquatable<ValueAction<T1, T2, T3, T4, T5>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueAction(MethodInfo method)
- public ValueAction(Action<T1, T2, T3, T4, T5> action, bool wrap = false)
- public ValueAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueAction first, ref ValueAction second)
- public static Action<T1, T2, T3, T4, T5> op_Explicit(ref ValueAction pointer)
- public static bool op_Inequality(ref ValueAction first, ref ValueAction second)
- public bool Equals(ValueAction<T1, T2, T3, T4, T5> other)
- public void Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
- public Action<T1, T2, T3, T4, T5> ToDelegate()
public struct ValueFunc<R> : ICallable<Func<R>>, ICallable, IEquatable<ValueFunc<R>>, ISupplier<R>
- public static ValueFunc<R> Activator { get; }
- public static ValueFunc<R> DefaultValueProvider { get; }
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueFunc(MethodInfo method)
- public ValueFunc(Func<R> func, bool wrap = false)
- public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
- public static Func<R> op_Explicit(ref ValueFunc pointer)
- public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
- public bool Equals(ValueFunc<R> other)
- public R Invoke()
- public Func<R> ToDelegate()
public struct ValueFunc<T, R> : ICallable<Func<T, R>>, ICallable, ICallable<Converter<T, R>>, IEquatable<ValueFunc<T, R>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueFunc(MethodInfo method)
- public ValueFunc(Func<T, R> func, bool wrap = false)
- public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
- public static Func<T, R> op_Explicit(ref ValueFunc func)
- public static Converter<T, R> op_Explicit(ref ValueFunc func)
- public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
- public bool Equals(ValueFunc<T, R> other)
- public R Invoke(T arg)
- public Func<T, R> ToDelegate()
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 object Target { get; }
- public ValueFunc(MethodInfo method)
- public ValueFunc(Func<T1, T2, R> func, bool wrap = false)
- public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
- public static Func<T1, T2, R> op_Explicit(ref ValueFunc pointer)
- public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
- public bool Equals(ValueFunc<T1, T2, R> other)
- public R Invoke(T1 arg1, T2 arg2)
- public Func<T1, T2, R> ToDelegate()
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 object Target { get; }
- public ValueFunc(MethodInfo method)
- public ValueFunc(Func<T1, T2, T3, R> func, bool wrap = false)
- public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
- public static Func<T1, T2, T3, R> op_Explicit(ref ValueFunc pointer)
- public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
- public bool Equals(ValueFunc<T1, T2, T3, R> other)
- public R Invoke(T1 arg1, T2 arg2, T3 arg3)
- public Func<T1, T2, T3, R> ToDelegate()
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 object Target { get; }
- public ValueFunc(MethodInfo method)
- public ValueFunc(Func<T1, T2, T3, T4, R> func, bool wrap = false)
- public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
- public static Func<T1, T2, T3, T4, R> op_Explicit(ref ValueFunc pointer)
- public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
- public bool Equals(ValueFunc<T1, T2, T3, T4, R> other)
- public R Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
- public Func<T1, T2, T3, T4, R> ToDelegate()
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 object Target { get; }
- public ValueFunc(MethodInfo method)
- public ValueFunc(Func<T1, T2, T3, T4, T5, R> func, bool wrap = false)
- public ValueFunc(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueFunc first, ref ValueFunc second)
- public static Func<T1, T2, T3, T4, T5, R> op_Explicit(ref ValueFunc pointer)
- public static bool op_Inequality(ref ValueFunc first, ref ValueFunc second)
- public bool Equals(ValueFunc<T1, T2, T3, T4, T5, R> other)
- public R Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
- public Func<T1, T2, T3, T4, T5, R> ToDelegate()
public struct ValueRefAction<T, TArgs> : ICallable<RefAction<T, TArgs>>, ICallable, IEquatable<ValueRefAction<T, TArgs>>
- public bool IsEmpty { get; }
- public object Target { get; }
- public ValueRefAction(MethodInfo method)
- public ValueRefAction(RefAction<T, TArgs> action, bool wrap = false)
- public ValueRefAction(IntPtr modreq(DotNext.Runtime.CompilerServices.ManagedMethodPointer) methodPtr)
- public static bool op_Equality(ref ValueRefAction first, ref ValueRefAction second)
- public static RefAction<T, TArgs> op_Explicit(ref ValueRefAction pointer)
- public static bool op_Inequality(ref ValueRefAction first, ref ValueRefAction second)
- public bool Equals(ValueRefAction<T, TArgs> other)
- public void Invoke(ref T reference, TArgs args)
- public RefAction<T, TArgs> ToDelegate()
public struct ValueRefFunc<T, TArgs, TResult> : 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 IntPtr Add(this IntPtr x, IntPtr y)
- public static UIntPtr Add(this UIntPtr x, UIntPtr y)
- public static IntPtr AddChecked(this IntPtr x, IntPtr y)
- public static UIntPtr AddChecked(this UIntPtr x, UIntPtr y)
- public static UIntPtr And(this UIntPtr x, UIntPtr y)
- public static IntPtr And(this IntPtr x, IntPtr y)
- public static IntPtr Decrement(this IntPtr value)
- public static UIntPtr Decrement(this UIntPtr value)
- public static IntPtr Divide(this IntPtr x, IntPtr y)
- public static UIntPtr Divide(this UIntPtr x, UIntPtr y)
- public static float EnsureFinite(this float value)
- public static double EnsureFinite(this double value)
- public static bool GreaterThan(this IntPtr value, IntPtr comparand)
- public static bool GreaterThan(this UIntPtr value, UIntPtr comparand)
- public static bool GreaterThanOrEqual(this IntPtr value, IntPtr comparand)
- public static bool GreaterThanOrEqual(this UIntPtr value, UIntPtr comparand)
- public static IntPtr Increment(this IntPtr value)
- public static UIntPtr Increment(this UIntPtr value)
- public static double Normalize(this ulong value)
- public static double Normalize(this long value)
- public static float Normalize(this uint value)
- public static float Normalize(this int value)
- public static double NormalizeToDouble<T>(this T value, T min, T max) where T : struct, IConvertible, IComparable<T>
- public static float NormalizeToSingle<T>(this T value, T min, T max) where T : struct, IConvertible, IComparable<T>
- public static bool LessThan(this IntPtr value, IntPtr comparand)
- public static bool LessThan(this UIntPtr value, UIntPtr comparand)
- public static bool LessThanOrEqual(this IntPtr value, IntPtr comparand)
- public static bool LessThanOrEqual(this UIntPtr value, UIntPtr comparand)
- public static IntPtr Multiply(this IntPtr x, IntPtr y)
- public static UIntPtr Multiply(this UIntPtr x, UIntPtr y)
- public static IntPtr MultiplyChecked(this IntPtr x, IntPtr y)
- public static UIntPtr MultiplyChecked(this UIntPtr x, UIntPtr y)
- public static IntPtr Negate(this IntPtr value)
- public static IntPtr OnesComplement(this IntPtr value)
- public static UIntPtr OnesComplement(this UIntPtr value)
- public static IntPtr Or(this IntPtr x, IntPtr y)
- public static UIntPtr Or(this UIntPtr x, UIntPtr y)
- public static IntPtr Subtract(this IntPtr x, IntPtr y)
- public static UIntPtr Subtract(this UIntPtr x, UIntPtr y)
- public static IntPtr SubtractChecked(this IntPtr x, IntPtr y)
- public static UIntPtr SubtractChecked(this UIntPtr x, UIntPtr y)
- public static byte ToByte(this bool value)
- public static int Truncate(this long value)
- public static bool TryGetValue<T>(this T? nullable, out T value) where T : struct
- public static IntPtr ToIntPtr(this UIntPtr value)
- public static UIntPtr ToUIntPtr(this IntPtr value)
- public static bool TryGet<T>(this ref Nullable nullable, out T value) where T : struct
- public static IntPtr Xor(this IntPtr x, IntPtr y)
- public static UIntPtr Xor(this UIntPtr x, UIntPtr y)

DotNext.Buffers

public struct BufferConsumer<T> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IEquatable<BufferConsumer<T>>
public static class BufferHelpers
public abstract class BufferWriter<T> : Disposable, IBufferWriter<T>, ISupplier<ReadOnlyMemory<T>>, IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IGrowableBuffer<T>, IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IDisposable
public struct BufferWriterInterpolatedStringHandler
public struct BufferWriterSlim<T>
public struct BufferWriterSlimInterpolatedStringHandler
public struct DelegatingReadOnlySpanConsumer<T, TArg> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>
public interface IBinaryFormattable<TSelf> where TSelf : IBinaryFormattable<TSelf>
public interface IGrowableBuffer<T> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IDisposable
public interface IReadOnlySpanConsumer<T> : ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>
public static class MemoryAllocator
public sealed delegate MemoryAllocator<T> : MulticastDelegate
public struct MemoryOwner<T> : IMemoryOwner<T>, IDisposable, ISupplier<Memory<T>>, ISupplier<ReadOnlyMemory<T>>
public struct ArrayRental<T> : IDisposable
- public bool IsEmpty { get; }
- public ref T this[long index] { get; }
- public int Length { get; }
- public Memory<T> Memory { get; }
- public ArraySegment<T> Segment { get; }
- public Span<T> Span { get; }
- public ArrayRental(ArrayPool<T> pool, int minimumLength, bool clearArray = false)
- public ArrayRental(int minimumLength, bool clearArray = false)
- public ArrayRental(T[] array, int length)
- public ArrayRental(T[] array)
- public static T[] op_Explicit(ref ArrayRental rental)
- public void Dispose()
- public ref T GetPinnableReference()
- public ArraySegment<T> Slice(int offset, int count)
public static class ChunkSequence
- public static Task CopyToAsync(this ChunkSequence<byte> sequence, Stream output, CancellationToken token = default)
- public static Task CopyToAsync(this ChunkSequence<char> sequence, TextWriter output, CancellationToken token = default)
public struct ChunkSequence<T> : IEnumerable<ReadOnlyMemory<T>>, IEnumerable
- public struct Enumerator<T> : IEnumerator<ReadOnlyMemory<T>>, IEnumerator, IDisposable
- public ChunkSequence(ReadOnlyMemory<T> memory, int chunkSize)
- public static ReadOnlySequence<T> op_Explicit(ChunkSequence<T> sequence)
- public Enumerator<T> GetEnumerator()
- public ReadOnlySequence<T> ToReadOnlySequence()
public struct MemoryRental<T>
- public static int StackallocThreshold { get; }
- public MemoryRental(Span<T> span, int length)
- public MemoryRental(MemoryPool<T> pool, int minBufferSize, bool exactSize = true)
- public MemoryRental(MemoryPool<T> pool)
- public MemoryRental(int minBufferSize, bool exactSize = true)
- public MemoryRental(MemoryPool<T> pool, int minBufferSize)
- public MemoryRental(int minBufferSize)
public static class MemoryTemplate
public struct MemoryTemplate<T> where T : IEquatable<T>
public sealed class PooledArrayBufferWriter<T> : BufferWriter<T>, ISupplier<ArraySegment<T>>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
public sealed class PooledBufferWriter<T> : BufferWriter<T>, IMemoryOwner<T>, IDisposable
public static class ReadOnlySequencePartitioner
public struct ReadOnlySpanConsumer<T, TArg> : IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>
public struct SpanReader<T>
public struct SpanWriter<T>
public enum SparseBufferGrowth
public class SparseBufferWriter<T> : Disposable, IEnumerable<ReadOnlyMemory<T>>, IEnumerable, IGrowableBuffer<T>, IReadOnlySpanConsumer<T>, ISupplier<ReadOnlyMemory<T>, CancellationToken, ValueTask>, IDisposable, ISupplier<ReadOnlySequence<T>>, IBufferWriter<T>

DotNext.Collections.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 long Count { get; }
- public T this[long index] { get; set; }
- public ReadOnlyMemory<T> Snapshot { get; }
- public CopyOnWriteList(IReadOnlyCollection<T> collection)
- public CopyOnWriteList()
- public static ReadOnlySpan<T> op_Explicit(CopyOnWriteList<T> list)
- public void Add(T item)
- public void Clear()
- public void Clear(ref ValueAction cleaner)
- public void Clear(Action<T> cleaner)
- public CopyOnWriteList<T> Clone()
- public bool Contains(T item)
- public void CopyTo(T[] array, int arrayIndex)
- public bool Exists(Predicate<T> match)
- public T Find(Predicate<T> match)
- public int FindIndex(Predicate<T> match)
- public T FindLast(Predicate<T> match)
- public int FindLastIndex(Predicate<T> match)
- public Enumerator<T> GetEnumerator()
- public int IndexOf(T item)
- public void Insert(long index, T item)
- public int LastIndexOf(T item)
- public bool Remove(T item)
- public long RemoveAll(ValueFunc<T, bool> match)
- public long RemoveAll(Predicate<T> match)
- public void RemoveAll(ref ValueFunc match, ref ValueAction callback)
- public void RemoveAll(Predicate<T> match, Action<T> callback)
- public void RemoveAt(long index)
- public void Set(ReadOnlySpan<T> array)
- public void Set<G>(ICollection<G> items, ref ValueFunc converter)
- public void Set<G>(ICollection<G> items, Converter<G, T> converter)

DotNext.Collections.Generic

public static class Collection
- public static ReadOnlyCollectionView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyCollection<TInput> collection, Converter<TInput, TOutput> converter)
- public static Optional<T> PeekRandom<T>(this IReadOnlyCollection<T> collection, Random random)
- public static ReadOnlyCollectionView<I, O> Convert<I, O>(this IReadOnlyCollection collection, ref ValueFunc converter)
- public static ReadOnlyCollectionView<I, O> Convert<I, O>(this IReadOnlyCollection collection, Converter<I, O> converter)
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, T> ConvertValues<K, V, T>(this IReadOnlyDictionary<K, V> dictionary, ref ValueFunc mapper)
- public static ReadOnlyDictionaryView<K, V, T> ConvertValues<K, V, T>(this IReadOnlyDictionary<K, V> dictionary, Converter<V, T> mapper)
- 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, ref ValueAction action)
- 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)
- 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, ref ValueFunc valueFactory)
- 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, ref ValueFunc defaultValue)
- 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 Optional<V> TryGetValue<K, V>(this IDictionary<K, V> dictionary, K key)
- public static Optional<V> TryGetValue<K, V>(IReadOnlyDictionary<K, V> dictionary, K key)
- public static Optional<V> TryRemove<K, V>(this IDictionary<K, V> dictionary, K key)
public static class List
- public static ReadOnlyListView<TInput, TOutput> Convert<TInput, TOutput>(this IReadOnlyList<TInput> list, Converter<TInput, TOutput> converter)
- public static ReadOnlyListView<I, O> Convert<I, O>(this IReadOnlyList list, ref ValueFunc converter)
- public static ReadOnlyListView<I, O> Convert<I, O>(this IReadOnlyList 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, ref ValueFunc 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 void Shuffle<T>(this IList<T> list, Random random)
- 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 input, ref ValueFunc mapper)
- public static O[] ToArray<I, O>(this IList input, Converter<I, O> mapper)
- public static O[] ToArray<I, O>(this IList input, ref ValueFunc mapper)
- public static O[] ToArray<I, O>(this IList input, Func<int, I, O> mapper)
public struct ListSegment<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyList<T>, IReadOnlyCollection<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 collection, ref ValueFunc 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, 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, ref ValueFunc 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<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 list, ref ValueFunc 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 Sequence
public static class Stack
- public static Stack<T> Clone<T>(this Stack<T> original)
- public static bool TryPeek<T>(this Stack<T> stack, out T obj)
- public static bool TryPop<T>(this Stack<T> stack, out T obj)

DotNext.Collections.Specialized

public class ConcurrentTypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>
public static class InvocationList
public struct InvocationList<TDelegate> : IReadOnlyCollection<TDelegate>, IEnumerable<TDelegate>, IEnumerable where TDelegate : MulticastDelegate
public interface IReadOnlyTypeMap<TValue>
public interface ITypeMap<TValue> : IReadOnlyTypeMap<TValue>
public struct SingletonList<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IList<T>, ICollection<T>
public class TypeMap<TValue> : ITypeMap<TValue>, IReadOnlyTypeMap<TValue>

DotNext.Diagnostics

public struct Timestamp : IEquatable<Timestamp>, IComparable<Timestamp>
- public static Timestamp op_Addition(Timestamp x, TimeSpan y)
- public static Timestamp op_Subtraction(Timestamp x, TimeSpan y)
- public static Timestamp VolatileRead(ref Timestamp location)
- public static void VolatileWrite(ref Timestamp location, Timestamp newValue)

DotNext.Generic

public abstract class Constant<T>
- public T Value { get; }
public abstract class Int32Const : Constant<int>
public abstract class Int64Const : Constant<long>
public abstract class IntConst : Constant<int>
- public sealed class Max : IntConst
- public sealed class Min : IntConst
- public sealed class Zero : IntConst
- protected IntConst(int value)
public abstract class LongConst : Constant<long>
- public sealed class Max : LongConst
- public sealed class Min : LongConst
- public sealed class Zero : LongConst
- protected LongConst(long value)

DotNext.IO

public interface IFlushable
public struct StreamConsumer : IReadOnlySpanConsumer<byte>, ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>, IEquatable<StreamConsumer>, IFlushable
public static class StreamSource
public struct TextConsumer : IReadOnlySpanConsumer<char>, ISupplier<ReadOnlyMemory<char>, CancellationToken, ValueTask>, IFlushable
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.Net.Http

public sealed class HttpEndPoint : DnsEndPoint, ISupplier<UriBuilder>, IEquatable<HttpEndPoint>

DotNext.Net.NetworkInformation

public class MtuDiscovery : Ping
public class MtuDiscoveryOptions : PingOptions

DotNext.Numerics

public static class BitVector

DotNext.Reflection

public static class CustomAttribute
- public static bool IsDefined<TAttribute>(this ICustomAttributeProvider member, bool inherit = false) where TAttribute : Attribute
- public static bool IsDefined<A>(this MemberInfo member, bool inherit = false) where A : Attribute
- public static bool IsDefined<A>(this Module module) where A : Attribute
- public static bool IsDefined<A>(this Assembly assembly) where A : Attribute
- public static bool IsDefined<A>(this ParameterInfo parameter) where A : Attribute
public static class DisposableType
- public static MethodInfo GetDisposeAsyncMethod(this Type type)
public static class EnumType
public static class MethodExtensions
- public static Result<object> TryInvoke(this MethodBase method, object obj, object[] args)
public static class TaskType
- public static Func<Task, bool> IsCompletedSuccessfullyGetter { get; }
- public static Func<Task<T>, T> GetResultGetter<T>()
- public static Type MakeTaskType(this Type taskResult, bool valueTask)
public static class TypeExtensions
- public static MethodInfo GetMethod(this Type type, string methodName, BindingFlags flags, long genericParamCount, Type[] parameters)
- public static MethodInfo GetMethod(this Type type, string name, BindingFlags flags, Type[] parameters)

DotNext.Resources

public struct ResourceEntry
public static class ResourceManagerExtensions

DotNext.Runtime

public static class Intrinsics
- public static IntPtr AddressOf<T>(ref T value)
- public static bool AreSame<T>(ref T first, ref T second)
- public static ref T AsRef<T>(TypedReference reference)
- public static T Cast<T>(object obj)
- public static void ClearBits(Void* address, IntPtr length)
- public static int Compare(Void* first, Void* second, IntPtr length)
- public static void Copy<T>(ref T input, out T output) where T : struct
- public static void Copy<T>(T* input, T* output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void Copy<T>(ref T source, out T destination, long count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void CopyUnaligned<T>(T* input, T* output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static bool Equals(Void* first, Void* second, IntPtr length)
- public static Exception Error(object obj)
- public static int GetHashCode32<T>(Func<T, int, int> getter, int count, T arg, bool salted = true)
- public static int GetHashCode32(Void* source, IntPtr length, int hash, Func<int, int, int> hashFunction, bool salted = true)
- public static int GetHashCode32<THashFunction>(Void* source, IntPtr length, bool salted = true) where THashFunction : struct, IConsumer<int>, ISupplier<int>
- public static int GetHashCode32(Void* source, IntPtr length, bool salted = true)
- public static long GetHashCode64<T>(Func<T, int, long> getter, int count, T arg, bool salted = true)
- public static long GetHashCode64(Void* source, IntPtr length, long hash, Func<long, long, long> hashFunction, bool salted = true)
- public static long GetHashCode64<THashFunction>(Void* source, IntPtr length, bool salted = true) where THashFunction : struct, IConsumer<long>, ISupplier<long>
- public static long GetHashCode64(Void* source, IntPtr length, bool salted = true)
- public static IntPtr GetLength(Array array)
- public static TBase& modreq(System.Runtime.InteropServices.InAttribute) GetReadonlyRef<T, TBase>(T[] array, IntPtr index) where T : TBase
- public static bool IsDefault<T>(ref T value)
- public static bool IsExactTypeOf<T>(object obj)
- public static bool IsDefault<T>(T value)
- public static int PointerHashCode(Void* pointer)
- public static void Reverse<T>(ref T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static T ShallowCopy<T>(T obj)
- public static void Swap<T>(ref T first, ref T second)
- public static void Swap<T>(T* first, T* second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void Throw(object obj)
- public static void ThrowIfNull<T>(ref T value)
public static class Reference
public struct Reference<TValue>

DotNext.Runtime.CompilerServices

public sealed class FunctionalInterfaceAttribute : Attribute
public sealed class Shared<T> where T : struct
public abstract class AsyncDelegateFuture : Future<Task>, IAwaiter, IFuture, INotifyCompletion
- public IAwaiter GetAwaiter()
public struct ManagedMethodPointer : IEquatable<ManagedMethodPointer>
- public static bool op_Equality(ManagedMethodPointer x, ManagedMethodPointer y)
- public static bool op_Inequality(ManagedMethodPointer x, ManagedMethodPointer y)
- public bool Equals(ManagedMethodPointer other)
public sealed class RuntimeFeaturesAttribute : Attribute
- public bool Augmentation
- public bool DynamicCodeCompilation
- public bool PrivateReflection
- public bool RuntimeGenericInstantiation
- public RuntimeFeaturesAttribute()

DotNext.Runtime.ExceptionServices

public struct ExceptionAggregator : ISupplier<Exception>

DotNext.Runtime.InteropServices

public static class SafeBufferExtensions
public static class Memory
- public static IntPtr AddressOf<T>(ref T value)
- public static bool AreSame<T>(ref T first, ref T second)
- public static ref T AsRef<T>(this TypedReference reference)
- public static Span<byte> AsSpan<T>(T* pointer) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void ClearBits(IntPtr address, long length)
- public static void ClearBits(Void* address, long length)
- public static int Compare(IntPtr first, IntPtr second, long length)
- public static int Compare(Void* first, Void* second, long length)
- public static void Copy(Void* source, Void* destination, long length)
- public static void Copy(IntPtr source, IntPtr destination, long length)
- public static void Copy<T>(ref T source, ref T destination, uint count) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void Copy<T>(ref T input, out T output) where T : struct
- public static void Copy<T>(T* input, T* output) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static bool Equals(Void* first, Void* second, long length)
- public static bool Equals(IntPtr first, IntPtr second, long length)
- public static int GetHashCode32(IntPtr source, long length, int hash, Func<int, int, int> hashFunction, bool salted = true)
- public static int GetHashCode32(IntPtr source, long length, int hash, ref ValueFunc hashFunction, bool salted = true)
- public static int GetHashCode32(Void* source, long length, int hash, Func<int, int, int> hashFunction, bool salted = true)
- public static int GetHashCode32(Void* source, long length, int hash, ref ValueFunc hashFunction, bool salted = true)
- public static int GetHashCode32(IntPtr source, long length, bool salted = true)
- public static int GetHashCode32(Void* source, long length, bool salted = true)
- public static long GetHashCode64(IntPtr source, long length, long hash, Func<long, long, long> hashFunction, bool salted = true)
- public static long GetHashCode64(IntPtr source, long length, long hash, ref ValueFunc hashFunction, bool salted = true)
- public static long GetHashCode64(Void* source, long length, long hash, Func<long, long, long> hashFunction, bool salted = true)
- public static long GetHashCode64(Void* source, long length, long hash, ref ValueFunc hashFunction, bool salted = true)
- public static long GetHashCode64(IntPtr source, long length, bool salted = true)
- public static long GetHashCode64(Void* source, long length, bool salted = true)
- public static T& modreq(System.Runtime.InteropServices.InAttribute) GetReadonlyRef<T>(this T[] array, long index)
- public static bool IsNull<T>(ref T value)
- public static T Read<T>(ref IntPtr source) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static string ReadString(ref IntPtr source)
- public static T ReadUnaligned<T>(ref IntPtr source) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void Swap<T>(ref T first, ref T second)
- public static void Swap<T>(T* first, T* second) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static void ThrowIfNull<T>(ref T value)
- public static T* ToPointer<T>(this IntPtr source) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
- public static T* ToPointer<T>(this UIntPtr 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 WriteString(ref IntPtr destination, ReadOnlySpan<char> str)
- public static void WriteString(ref IntPtr destination, string str)
- public static void WriteUnaligned<T>(ref IntPtr destination, T value) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)

DotNext.Text

public struct Base64Decoder
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()
public static class EncodingExtensions
- public static MemoryOwner<byte> GetBytes(this Encoding encoding, ReadOnlySpan<char> chars, MemoryAllocator<byte> allocator = null)
- public static MemoryOwner<char> GetChars(this Encoding encoding, ReadOnlySpan<byte> bytes, MemoryAllocator<char> allocator = null)

DotNext.Text.Json

public sealed class OptionalConverter<T> : JsonConverter<Optional<T>>
public sealed class OptionalConverterFactory : JsonConverterFactory

DotNext.Threading

public static class AsyncDelegate
- public static Task BeginInvoke(this Action<object> action, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null)
- public static Task BeginInvoke(this Action<object, CancellationToken> action, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null, CancellationToken token = default)
- public static Task<TResult> BeginInvoke<TResult>(this Func<object, TResult> function, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null)
- public static Task<TResult> BeginInvoke<TResult>(this Func<object, CancellationToken, TResult> function, object state, AsyncCallback callback, TaskCreationOptions options = 0, TaskScheduler scheduler = null, CancellationToken token = default)
- public static Task InvokeAsync<TDelegate>(this TDelegate delegate, Action<TDelegate> invoker, CancellationToken token = default) where TDelegate : MulticastDelegate
- public static Task InvokeAsync<TEventArgs>(this EventHandler<TEventArgs> handler, object sender, TEventArgs args, CancellationToken token = default)
- public static Task InvokeAsync(this EventHandler handler, object sender, EventArgs args, CancellationToken token = default)
- public static Task InvokeAsync(this Action action, CancellationToken token = default)
- public static Task InvokeAsync<T>(this Action<T> action, T arg, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2>(this Action<T1, T2> action, T1 arg1, T2 arg2, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3>(this Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4, T5, T6>(this Action<T1, T2, T3, T4, T5, T6> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7>(this Action<T1, T2, T3, T4, T5, T6, T7> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Action<T1, T2, T3, T4, T5, T6, T7, T8> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, CancellationToken token = default)
- public static Task InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, CancellationToken token = default)
- public static AsyncDelegateFuture InvokeAsync<D>(this D delegate, Action<D> invoker, CancellationToken token = default) where D : MulticastDelegate
- public static AsyncDelegateFuture InvokeAsync<E>(this EventHandler<E> handler, object sender, E args, CancellationToken token = default)
- public static AsyncDelegateFuture InvokeAsync(this EventHandler handler, object sender, EventArgs args, CancellationToken token = default)
- public static AsyncDelegateFuture InvokeAsync(this Action action, CancellationToken token = default)
- public static AsyncDelegateFuture InvokeAsync<T>(this Action<T> action, T arg, CancellationToken token = default)
- public static AsyncDelegateFuture InvokeAsync<T1, T2>(this Action<T1, T2> action, T1 arg1, T2 arg2, CancellationToken token = default)
- public static AsyncDelegateFuture InvokeAsync<T1, T2, T3>(this Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3, CancellationToken token = default)
- public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, CancellationToken token = default)
- public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, CancellationToken token = default)
- public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6>(this Action<T1, T2, T3, T4, T5, T6> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, CancellationToken token = default)
- public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6, T7>(this Action<T1, T2, T3, T4, T5, T6, T7> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, CancellationToken token = default)
- public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Action<T1, T2, T3, T4, T5, T6, T7, T8> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, CancellationToken token = default)
- public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, CancellationToken token = default)
- public static AsyncDelegateFuture InvokeAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, CancellationToken token = default)
public struct Atomic<T> : IStrongBox, ICloneable where T : struct
- public bool CompareAndSet(Func<T, T, bool> comparer, ref T expected, ref T update)
- public bool CompareAndSet(method comparer, ref T expected, ref T update)
- public bool CompareExchange(ref T update, ref T expected, out T result)
- public bool CompareExchange(Func<T, T, bool> comparer, ref T update, ref T expected, out T result)
- public bool CompareExchange(method comparer, ref T update, ref T expected, out T result)
- public void CompareExchange(ref T update, ref T expected, out T result)
public struct AtomicBoolean : IEquatable<bool>, ISerializable
- public bool AccumulateAndGet(bool x, method accumulator)
- public bool AccumulateAndGet(bool x, ref ValueFunc accumulator)
- public bool GetAndAccumulate(bool x, method accumulator)
- public bool GetAndAccumulate(bool x, ref ValueFunc accumulator)
- public bool GetAndUpdate(method updater)
- public bool GetAndUpdate(ref ValueFunc updater)
- public bool UpdateAndGet(method updater)
- public bool UpdateAndGet(ref ValueFunc updater)
public static class AtomicDouble
- public static double AccumulateAndGet(this ref double value, double x, method accumulator)
- public static double AddAndGet(this ref double value, double operand)
- public static double AccumulateAndGet(this ref double value, double x, ref ValueFunc accumulator)
- public static double AccumulateAndGet(this double[] array, long index, double x, Func<double, double, double> accumulator)
- public static double AccumulateAndGet(this double[] array, long index, double x, ref ValueFunc 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 double[] array, long index, double expected, double update)
- public static double CompareExchange(this double[] array, long index, double update, double comparand)
- public static double DecrementAndGet(this double[] array, long index)
- public static double GetAndAccumulate(this ref double value, double x, method accumulator)
- public static double GetAndAdd(this ref double value, double operand)
- public static double GetAndAccumulate(this ref double value, double x, ref ValueFunc accumulator)
- public static double GetAndAccumulate(this double[] array, long index, double x, Func<double, double, double> accumulator)
- public static double GetAndAccumulate(this double[] array, long index, double x, ref ValueFunc accumulator)
- public static double GetAndSet(this double[] array, long index, double update)
- public static double GetAndUpdate(this ref double value, method updater)
- public static double GetAndUpdate(this ref double value, ref ValueFunc updater)
- public static double GetAndUpdate(this double[] array, long index, Func<double, double> updater)
- public static double GetAndUpdate(this double[] array, long index, ref ValueFunc updater)
- public static double IncrementAndGet(this double[] array, long index)
- public static double SetAndGet(this double[] array, long index, double update)
- public static double UpdateAndGet(this ref double value, method updater)
- public static double UpdateAndGet(this ref double value, ref ValueFunc updater)
- public static double UpdateAndGet(this double[] array, long index, Func<double, double> updater)
- public static double UpdateAndGet(this double[] array, long index, ref ValueFunc updater)
- public static double VolatileRead(this double[] array, long index)
- public static void VolatileWrite(this double[] array, long index, double value)
public static class AtomicEnum
- public static TEnum VolatileRead<TEnum>(this ref TEnum value) where TEnum : struct, Enum
- public static void VolatileWrite<TEnum>(this ref TEnum value, TEnum newValue) where TEnum : struct, Enum
- public static E VolatileRead<E>(this ref E value) where E : struct, Enum
- public static void VolatileWrite<E>(this ref E value, E newValue) where E : struct, Enum
public struct AtomicEnum<E> : IEquatable<E>, ISerializable where E : struct, Enum
- public TEnum Value { get; set; }
- public AtomicEnum(TEnum value)
- public TEnum AccumulateAndGet(TEnum x, Func<TEnum, TEnum, TEnum> accumulator)
- public TEnum AccumulateAndGet(TEnum x, method accumulator)
- public bool CompareAndSet(TEnum expected, TEnum update)
- public TEnum CompareExchange(TEnum update, TEnum expected)
- public bool Equals(TEnum other)
- public TEnum GetAndAccumulate(TEnum x, Func<TEnum, TEnum, TEnum> accumulator)
- public TEnum GetAndAccumulate(TEnum x, method accumulator)
- public TEnum GetAndSet(TEnum update)
- public TEnum GetAndUpdate(Func<TEnum, TEnum> updater)
- public TEnum GetAndUpdate(method updater)
- public TEnum SetAndGet(TEnum update)
- public TEnum UpdateAndGet(Func<TEnum, TEnum> updater)
- public TEnum UpdateAndGet(method updater)
- public E Value { get; set; }
- public AtomicEnum(E value)
- public E AccumulateAndGet(E x, Func<E, E, E> accumulator)
- public E AccumulateAndGet(E x, ref ValueFunc accumulator)
- public bool CompareAndSet(E expected, E update)
- public E CompareExchange(E update, E expected)
- public bool Equals(E other)
- public E GetAndAccumulate(E x, Func<E, E, E> accumulator)
- public E GetAndAccumulate(E x, ref ValueFunc accumulator)
- public E GetAndSet(E update)
- public E GetAndUpdate(Func<E, E> updater)
- public E GetAndUpdate(ref ValueFunc updater)
- public E SetAndGet(E update)
- public E UpdateAndGet(Func<E, E> updater)
- public E UpdateAndGet(ref ValueFunc updater)
public static class AtomicInt32
- public static int AccumulateAndGet(this ref int value, int x, method accumulator)
- public static int AddAndGet(this ref int value, int operand)
- public static int BitwiseAndAndGet(this ref int value, int operand)
- public static int BitwiseOrAndGet(this ref int value, int operand)
- public static int BitwiseXorAndGet(this ref int value, int operand)
- public static int AccumulateAndGet(this ref int value, int x, ref ValueFunc accumulator)
- public static int AccumulateAndGet(this int[] array, long index, int x, Func<int, int, int> accumulator)
- public static int AccumulateAndGet(this int[] array, long index, int x, ref ValueFunc 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 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 int[] array, long index)
- public static int GetAndAccumulate(this ref int value, int x, method accumulator)
- public static int GetAndAdd(this ref int value, int operand)
- public static int GetAndBitwiseAnd(this ref int value, int operand)
- public static int GetAndBitwiseOr(this ref int value, int operand)
- public static int GetAndBitwiseXor(this ref int value, int operand)
- public static int GetAndAccumulate(this ref int value, int x, ref ValueFunc accumulator)
- public static int GetAndAccumulate(this int[] array, long index, int x, Func<int, int, int> accumulator)
- public static int GetAndAccumulate(this int[] array, long index, int x, ref ValueFunc accumulator)
- public static int GetAndSet(this int[] array, long index, int update)
- public static int GetAndUpdate(this ref int value, method updater)
- public static int GetAndUpdate(this ref int value, ref ValueFunc updater)
- public static int GetAndUpdate(this int[] array, long index, Func<int, int> updater)
- public static int GetAndUpdate(this int[] array, long index, ref ValueFunc updater)
- public static int IncrementAndGet(this int[] array, long index)
- public static int SetAndGet(this int[] array, long index, int update)
- public static int UpdateAndGet(this ref int value, method updater)
- public static int UpdateAndGet(this ref int value, ref ValueFunc updater)
- public static int UpdateAndGet(this int[] array, long index, Func<int, int> updater)
- public static int UpdateAndGet(this int[] array, long index, ref ValueFunc updater)
- public static int VolatileRead(this int[] array, long index)
- public static void VolatileWrite(this int[] array, long index, int value)
public static class AtomicInt64
- public static long AccumulateAndGet(this ref long value, long x, method accumulator)
- public static long AddAndGet(this ref long value, long operand)
- public static long BitwiseAndAndGet(this ref long value, long operand)
- public static long BitwiseOrAndGet(this ref long value, long operand)
- public static long BitwiseXorAndGet(this ref long value, long operand)
- public static long AccumulateAndGet(this ref long value, long x, ref ValueFunc accumulator)
- public static long AccumulateAndGet(this long[] array, long index, long x, Func<long, long, long> accumulator)
- public static long AccumulateAndGet(this long[] array, long index, long x, ref ValueFunc 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 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 long[] array, long index)
- public static long GetAndAccumulate(this ref long value, long x, method accumulator)
- public static long GetAndAdd(this ref long value, long operand)
- public static long GetAndBitwiseAnd(this ref long value, long operand)
- public static long GetAndBitwiseOr(this ref long value, long operand)
- public static long GetAndBitwiseXor(this ref long value, long operand)
- public static long GetAndAccumulate(this ref long value, long x, ref ValueFunc accumulator)
- public static long GetAndAccumulate(this long[] array, long index, long x, Func<long, long, long> accumulator)
- public static long GetAndAccumulate(this long[] array, long index, long x, ref ValueFunc accumulator)
- public static long GetAndSet(this long[] array, long index, long update)
- public static long GetAndUpdate(this ref long value, method updater)
- public static long GetAndUpdate(this ref long value, ref ValueFunc updater)
- public static long GetAndUpdate(this long[] array, long index, Func<long, long> updater)
- public static long GetAndUpdate(this long[] array, long index, ref ValueFunc updater)
- public static long IncrementAndGet(this long[] array, long index)
- public static long SetAndGet(this long[] array, long index, long update)
- public static long UpdateAndGet(this ref long value, method updater)
- public static long UpdateAndGet(this ref long value, ref ValueFunc updater)
- public static long UpdateAndGet(this long[] array, long index, Func<long, long> updater)
- public static long UpdateAndGet(this long[] array, long index, ref ValueFunc updater)
- public static long VolatileRead(this long[] array, long index)
- public static void VolatileWrite(this long[] array, long index, long value)
public static class AtomicIntPtr
- public static IntPtr AccumulateAndGet(this ref IntPtr value, IntPtr x, method accumulator)
- public static IntPtr AddAndGet(this ref IntPtr value, IntPtr operand)
- public static IntPtr BitwiseAndAndGet(this ref IntPtr value, IntPtr operand)
- public static IntPtr BitwiseOrAndGet(this ref IntPtr value, IntPtr operand)
- public static IntPtr BitwiseXorAndGet(this ref IntPtr value, IntPtr operand)
- public static IntPtr AccumulateAndGet(this ref IntPtr value, IntPtr x, ref ValueFunc accumulator)
- public static IntPtr AccumulateAndGet(this IntPtr[] array, long index, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
- public static IntPtr AccumulateAndGet(this IntPtr[] array, long index, IntPtr x, ref ValueFunc accumulator)
- public static IntPtr Add(this ref IntPtr value, IntPtr operand)
- public static bool CompareAndSet(this IntPtr[] array, long index, IntPtr expected, IntPtr update)
- public static IntPtr CompareExchange(this IntPtr[] array, long index, IntPtr update, IntPtr comparand)
- public static IntPtr DecrementAndGet(this IntPtr[] array, long index)
- public static IntPtr GetAndAccumulate(this ref IntPtr value, IntPtr x, method accumulator)
- public static IntPtr GetAndAdd(this ref IntPtr value, IntPtr operand)
- public static IntPtr GetAndBitwiseAnd(this ref IntPtr value, IntPtr operand)
- public static IntPtr GetAndBitwiseOr(this ref IntPtr value, IntPtr operand)
- public static IntPtr GetAndBitwiseXor(this ref IntPtr value, IntPtr operand)
- public static IntPtr GetAndAccumulate(this ref IntPtr value, IntPtr x, ref ValueFunc accumulator)
- public static IntPtr GetAndAccumulate(this IntPtr[] array, long index, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
- public static IntPtr GetAndAccumulate(this IntPtr[] array, long index, IntPtr x, ref ValueFunc accumulator)
- public static IntPtr GetAndSet(this IntPtr[] array, long index, IntPtr update)
- public static IntPtr GetAndUpdate(this ref IntPtr value, method updater)
- public static IntPtr GetAndUpdate(this ref IntPtr value, ref ValueFunc updater)
- public static IntPtr GetAndUpdate(this IntPtr[] array, long index, Func<IntPtr, IntPtr> updater)
- public static IntPtr GetAndUpdate(this IntPtr[] array, long index, ref ValueFunc updater)
- public static IntPtr IncrementAndGet(this IntPtr[] array, long index)
- public static IntPtr SetAndGet(this IntPtr[] array, long index, IntPtr update)
- public static IntPtr UpdateAndGet(this ref IntPtr value, method updater)
- public static IntPtr UpdateAndGet(this ref IntPtr value, ref ValueFunc updater)
- public static IntPtr UpdateAndGet(this IntPtr[] array, long index, Func<IntPtr, IntPtr> updater)
- public static IntPtr UpdateAndGet(this IntPtr[] array, long index, ref ValueFunc updater)
- public static IntPtr VolatileRead(this IntPtr[] array, long index)
- public static void VolatileWrite(this IntPtr[] array, long index, IntPtr value)
public static class AtomicReference
- public static T AccumulateAndGet<T>(ref T value, T x, method accumulator)
- public static T AccumulateAndGet<T>(ref T value, T x, ref ValueFunc accumulator)
- public static T AccumulateAndGet<T>(this T[] array, long index, T x, Func<T, T, T> accumulator)
- public static T AccumulateAndGet<T>(this T[] array, long index, T x, ref ValueFunc accumulator)
- 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, method accumulator)
- public static T GetAndAccumulate<T>(ref T value, T x, ref ValueFunc accumulator)
- public static T GetAndAccumulate<T>(this T[] array, long index, T x, Func<T, T, T> accumulator)
- public static T GetAndAccumulate<T>(this T[] array, long index, T x, ref ValueFunc accumulator)
- public static T GetAndSet<T>(this T[] array, long index, T update)
- public static T GetAndUpdate<T>(ref T value, method updater)
- public static T GetAndUpdate<T>(ref T value, ref ValueFunc updater)
- public static T GetAndUpdate<T>(this T[] array, long index, Func<T, T> updater)
- public static T GetAndUpdate<T>(this T[] array, long index, ref ValueFunc updater)
- public static T SetAndGet<T>(this T[] array, long index, T update)
- public static T UpdateAndGet<T>(ref T value, method updater)
- public static T UpdateAndGet<T>(ref T value, ref ValueFunc updater)
- public static T UpdateAndGet<T>(this T[] array, long index, Func<T, T> updater)
- public static T UpdateAndGet<T>(this T[] array, long index, ref ValueFunc updater)
- public static T VolatileRead<T>(this T[] array, long index)
- public static void VolatileWrite<T>(this T[] array, long index, T element)
public struct AtomicReference<T> : IEquatable<T>, ISerializable
- public T Value { get; set; }
- public AtomicReference(T value)
- public T AccumulateAndGet(T x, Func<T, T, T> accumulator)
- public T AccumulateAndGet(T x, ref ValueFunc accumulator)
- public bool CompareAndSet(T expected, T update)
- public T CompareExchange(T expected, T update)
- public bool Equals(T other)
- public T GetAndAccumulate(T x, Func<T, T, T> accumulator)
- public T GetAndAccumulate(T x, ref ValueFunc accumulator)
- public T GetAndSet(T update)
- public T GetAndUpdate(Func<T, T> updater)
- public T GetAndUpdate(ref ValueFunc updater)
- public T SetAndGet(T update)
- public T SetIfNull<G>() where G : T
- public T SetIfNull(Func<T> supplier)
- public T UpdateAndGet(Func<T, T> updater)
- public T UpdateAndGet(ref ValueFunc updater)
public static class AtomicSingle
- public static float AccumulateAndGet(this ref float value, float x, method accumulator)
- public static float AddAndGet(this ref float value, float operand)
- public static float AccumulateAndGet(this ref float value, float x, ref ValueFunc accumulator)
- public static float AccumulateAndGet(this float[] array, long index, float x, Func<float, float, float> accumulator)
- public static float AccumulateAndGet(this float[] array, long index, float x, ref ValueFunc 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 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 float[] array, long index)
- public static float GetAndAccumulate(this ref float value, float x, method accumulator)
- public static float GetAndAdd(this ref float value, float operand)
- public static float GetAndAccumulate(this ref float value, float x, ref ValueFunc accumulator)
- public static float GetAndAccumulate(this float[] array, long index, float x, Func<float, float, float> accumulator)
- public static float GetAndAccumulate(this float[] array, long index, float x, ref ValueFunc accumulator)
- public static float GetAndSet(this float[] array, long index, float update)
- public static float GetAndUpdate(this ref float value, method updater)
- public static float GetAndUpdate(this ref float value, ref ValueFunc updater)
- public static float GetAndUpdate(this float[] array, long index, Func<float, float> updater)
- public static float GetAndUpdate(this float[] array, long index, ref ValueFunc updater)
- public static float IncrementAndGet(this float[] array, long index)
- public static float SetAndGet(this float[] array, long index, float update)
- public static float UpdateAndGet(this ref float value, method updater)
- public static float UpdateAndGet(this ref float value, ref ValueFunc updater)
- public static float UpdateAndGet(this float[] array, long index, Func<float, float> updater)
- public static float UpdateAndGet(this float[] array, long index, ref ValueFunc updater)
- public static float VolatileRead(this float[] array, long index)
- public static void VolatileWrite(this float[] array, long index, float value)
public static class AtomicUInt32
public static class AtomicUInt64
public struct ReaderWriterSpinLock
- public void DowngradeFromWriteLock()
- public bool TryUpgradeToWriteLock()
- public bool TryUpgradeToWriteLock(TimeSpan timeout, CancellationToken token = default)
- public void UpgradeToWriteLock()
public static class ThreadPoolWorkItemFactory
public struct Timeout
- public static Timeout Infinite { get; }
- public bool IsInfinite { get; }
- public TimeSpan? RemainingTime { get; }
- public TimeSpan Value { get; }

DotNext.Threading.Tasks

public static class Continuation
- public static Task<Task<TResult>> OnCompleted<TResult>(this Task<TResult> task)
- public static Task<Task<R>> OnCompleted<R>(this Task<R> task)
- public static Task<T> OnFaulted<T, TConstant>(this Task<T> task, Predicate<AggregateException> filter, TaskScheduler scheduler = null) where TConstant : Constant<T>
- public static Task<T> OnFaultedOrCanceled<T, TConstant>(this Task<T> task, Predicate<AggregateException> filter, TaskScheduler scheduler = null) where TConstant : Constant<T>
public 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 Task<O> Convert<I, O>(this Task task) where I : O
- public static Task<O> Convert<I, O>(this Task task, Converter<I, O> converter)
- public static Task<O> Convert<I, O>(this Task task, Converter<I, Task<O>> converter)
public struct DynamicTaskAwaitable
public abstract class Future : IFuture, INotifyCompletion
- public interface IAwaiter : IFuture, INotifyCompletion
- public interface IAwaiter<R> : IFuture, INotifyCompletion
- protected sealed class IncompletedFutureException : InvalidOperationException
- public abstract bool IsCompleted { get; }
- protected Future(bool runContinuationsAsynchronously = true)
- protected void Complete()
- public void OnCompleted(Action callback)
public abstract class Future<T> : Future where T : Task
- protected Future(bool runContinuationsAsynchronously = true)
- public abstract T AsTask()
public interface IFuture : INotifyCompletion
- bool IsCompleted { get; }
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 Result<R> GetResult<R>(this Task<R> task, TimeSpan timeout)
- public static Result<R> GetResult<R>(this Task<R> task, CancellationToken token)
- public static Task<bool> WaitAsync(this Task task, TimeSpan timeout, CancellationToken token = default)
- 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
- object Value { get; }
- bool Equals<V>(V other) where V : IVariant
public struct Variant<T1, T2> : IEquatable<Variant<T1, T2>>, IVariant, IDynamicMetaObjectProvider
- public Optional<T1> First { get; }
- public bool IsNull { 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>(ref ValueFunc mapper1, ref ValueFunc mapper2)
- public Optional<R> Convert<R>(Converter<T1, R> mapper1, Converter<T2, R> mapper2)
- public Variant<U1, U2> Convert<U1, U2>(ref ValueFunc mapper1, ref ValueFunc mapper2)
- public Variant<U1, U2> Convert<U1, U2>(Converter<T1, U1> mapper1, Converter<T2, U2> mapper2)
- public void Deconstruct(out T1 value1, out T2 value2)
- public bool Equals<V>(V other) where V : IVariant
- public Variant<T2, T1> Permute()
public struct Variant<T1, T2, T3> : IVariant, IDynamicMetaObjectProvider, IEquatable<Variant<T1, T2, T3>>
- public bool IsNull { 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 void Deconstruct(out T1 value1, out T2 value2, out T3 value3)
- public bool Equals<V>(V other) where V : IVariant
- public Variant<T3, T1, T2> Permute()
public struct Variant<T1, T2, T3, T4> : IVariant, IDynamicMetaObjectProvider, IEquatable<Variant<T1, T2, T3, T4>>
- public bool IsNull { 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 void Deconstruct(out T1 value1, out T2 value2, out T3 value3, out T4 value4)
- public bool Equals<V>(V other) where V : IVariant
- public Variant<T4, T1, T2, T3> Permute()