ArraySectionT Structure

[SerializableAttribute]
public struct ArraySection<T> : IList<T>, 
	ICollection<T>, IEnumerable<T>, IEnumerable, IList, ICollection, 
	IEquatable<ArraySection<T>>, IReadOnlyList<T>, IReadOnlyCollection<T>

// The actual underlying buffer we want to use.
var buffer = new byte[256];

// Note that none of the lines below allocate anything on the heap.

// So far similar to AsSpan or AsMemory extensions, but this is available on all platforms:
ArraySection<byte> section = buffer.AsSection(25, 100); // 100 bytes starting at index 25

// But if you wish you can treat it as a 10x10 two-dimensional array:
Array2D<byte> as2d = section.AsArray2D(10, 10); // an Array3D can be created in a similar way

// 2D indexing works the same way as for a real multidimensional array. But this is actually faster:
byte element = as2d[2, 3]; // row index first, then column index (similarly to regular arrays)

// Slicing works the same way as for ArraySection/Spans:
Array2D<byte> someRows = as2d[1..^1]; // same as as2d.Slice(1, as2d.Height - 2)

// Or you can get a simple row:
ArraySection<byte> singleRow = as2d[0];

// You can even reinterpret the element type if you whish:
CastArray<byte, Color32> asColors = section.Cast<byte, Color32>();

// Now you can access the elements cast to the reinterpreted type:
Color32 c = asColors[0];

// Or the reference to them (if supported by the compiler you use):
ref Color32 cRef = ref asColors.GetElementReference(0);

// Casts also have their 2D/3D counterparts:
CastArray2D<byte, Color32> asColors2D = asColors.As2D(height: 4, width: 6);

// Same as above, but directly from the section:
asColors2D = section.Cast2D<byte, Color32>(4, 6);