public struct ImmutableArray<T> : IReadOnlyList<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, IList<T>, ICollection<T>, IEquatable<ImmutableArray<T>>, IImmutableList<T>, IList, ICollection, IImmutableArray, IStructuralComparable, IStructuralEquatable

public sealed class Builder<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyList<T>, IReadOnlyCollection<T>

public struct Enumerator<T>

public static readonly ImmutableArray<T> Empty

public bool IsDefault { get; }

public bool IsDefaultOrEmpty { get; }

public bool IsEmpty { get; }

public T this[int index] { get; }

public int Length { get; }

public static ImmutableArray<T> CastUp<TDerived>(ImmutableArray<TDerived> items) where TDerived : T

public static bool op_Equality(ImmutableArray<T> left, ImmutableArray<T> right)

public static bool op_Equality(ImmutableArray<T>? left, ImmutableArray<T>? right)

public static bool op_Inequality(ImmutableArray<T> left, ImmutableArray<T> right)

public static bool op_Inequality(ImmutableArray<T>? left, ImmutableArray<T>? right)

public ImmutableArray<T> Add(T item)

public ImmutableArray<T> AddRange(IEnumerable<T> items)

public ImmutableArray<T> AddRange(ImmutableArray<T> items)

public ImmutableArray<TOther> As<TOther>()

public ImmutableArray<TOther> CastArray<TOther>()

public ImmutableArray<T> Clear()

public bool Contains(T item)

public void CopyTo(T[] destination)

public void CopyTo(T[] destination, int destinationIndex)

public void CopyTo(int sourceIndex, T[] destination, int destinationIndex, int length)

public bool Equals(ImmutableArray<T> other)

public Enumerator<T> GetEnumerator()

public int IndexOf(T item)

public int IndexOf(T item, int startIndex, IEqualityComparer<T> equalityComparer)

public int IndexOf(T item, int startIndex)

public int IndexOf(T item, int startIndex, int count)

public int IndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer)

public ImmutableArray<T> Insert(int index, T item)

public ImmutableArray<T> InsertRange(int index, IEnumerable<T> items)

public ImmutableArray<T> InsertRange(int index, ImmutableArray<T> items)

public int LastIndexOf(T item)

public int LastIndexOf(T item, int startIndex)

public int LastIndexOf(T item, int startIndex, int count)

public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer)

public IEnumerable<TResult> OfType<TResult>()

public ImmutableArray<T> Remove(T item)

public ImmutableArray<T> Remove(T item, IEqualityComparer<T> equalityComparer)

public ImmutableArray<T> RemoveAll(Predicate<T> match)

public ImmutableArray<T> RemoveAt(int index)

public ImmutableArray<T> RemoveRange(int index, int length)

public ImmutableArray<T> RemoveRange(IEnumerable<T> items)

public ImmutableArray<T> RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer)

public ImmutableArray<T> RemoveRange(ImmutableArray<T> items)

public ImmutableArray<T> RemoveRange(ImmutableArray<T> items, IEqualityComparer<T> equalityComparer)

public ImmutableArray<T> Replace(T oldValue, T newValue)

public ImmutableArray<T> Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer)

public ImmutableArray<T> SetItem(int index, T item)

public ImmutableArray<T> Sort()

public ImmutableArray<T> Sort(Comparison<T> comparison)

public ImmutableArray<T> Sort(IComparer<T> comparer)

public ImmutableArray<T> Sort(int index, int count, IComparer<T> comparer)

public Builder<T> ToBuilder()