Get Memory<T>/ReadOnlyMemory<T> from multidimensional array of T.

[josephmoresena]

There is no way to retrieve a Memory or ReadOnlyMemory from a non-unidimensional array, even though multidimensional arrays are stored in a contiguous memory region. This should be possible since multidimensional arrays are stored in contiguous memory.

[huoyaoyuan]

There lacks a way to represent "array of any dimensions of T", or T[*]. So there's no way to provide a type-safe api without enumerating each dimensions.

With unsafe code, this can be achieved by:

MemoryMarshal.CreateSpan(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array)), array.Length);

For Memory<T> it's different. Memory<T> needs knowledge about underlying object, and doesn't support md array.

[josephmoresena]

Could using MemoryManager achieve this?

With this, we can implement GetSpan(). Since we have an array instance, we can obtain a pinned GCHandle from it and use that to create a MemoryHandle instance to implement Pin(Int32).

By doing this, we might be able to create extensions for T[,], T[,,], and so on. The unused functions might be trimmed, but it could be a viable approach.

[huoyaoyuan]

It should be achievable. The Memory<T>.Span accessor will be slower, but it won't typically be an issue for large arrays.

[josephmoresena]

I still have doubts about the implementation of the Dispose(Boolean) and Unpin() methods, especially regarding how they would be called and the number of times Pin(Int32) and Unpin() might be invoked.

Do you think this approach could be incorporated into the MemoryExtensions class?
Currently, for T[], there are: AsMemory<T>(T[]), AsMemory<T>(T[], Index), AsMemory<T>(T[], Int32), AsMemory<T>(T[], Int32, Int32), and AsMemory<T>(T[], Range).

However, to be honest, the only one that would make sense in this context is the first one method.

[huoyaoyuan]

It's likely beyond the scope of MemoryExtensions as it require non-trivial wrapping. And also, Range doesn't fit naturally with md array.