Memória2D<T>

O Memory2D<T> é um tipo que espelha a funcionalidade do tipo Memory<T>, com a diferença de que ele pode ser usado para representar localizações de memória 2D. É extremamente flexível e é capaz de encapsular vários tipos diferentes, incluindo arrays ND (com suporte explícito para arrays 1D, 2D e 3D) ou Memory<T> instâncias. Este tipo destina-se a ser usado em conjunto com o Span2D<T> tipo, da mesma forma que Memory<T> é usado juntamente com Span<T>. Para obter mais informações sobre as principais diferenças e cenários de casos de uso desses dois tipos, você pode ler esta página de documentos.

APIs da plataforma:Memory2D<T>, Span2D<T>, ReadOnlyMemory2D<T>

Como funciona

O Memory2D<T> tipo rastreia internamente a área de memória 2D mapeada através de uma referência ao objeto encapsulado, os parâmetros de altura e largura e um parâmetro de passo especial. A altura e a largura indicam a extensão das linhas e colunas na área de memória 2D, já que o passo indica o deslocamento entre o final de cada linha e o início da seguinte.

Aqui está um diagrama simples que ilustra essa configuração (as células "XX" na grade representam itens pertencentes à área de memória 2D de destino):

//                _____________________stride_____...
//  reference__  /________width_________  ________...
//             \/                       \/
// | -- | -- | |- | -- | -- | -- | -- | -- | -- | -- |_
// | -- | -- | XX | XX | XX | XX | XX | XX | -- | -- | |
// | -- | -- | XX | XX | XX | XX | XX | XX | -- | -- | |
// | -- | -- | XX | XX | XX | XX | XX | XX | -- | -- | |_height
// | -- | -- | XX | XX | XX | XX | XX | XX | -- | -- |_|
// | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- |
// | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- |
// ...__pitch__/
// ...________/

Esta configuração permite Memory2D<T> ser extremamente flexível na forma como mapeia buffers existentes para áreas de memória 2D, pois torna possível também representar buffers descontíguos como um local de memória 2D "virtual". Por exemplo, aqui estão alguns exemplos de tipos de buffer para os quais uma Memory2D instância pode ser mapeada:

• Uma matriz 1D T[] que é mapeada como uma área de memória 2D em ordem de linha maior.
• Uma matriz 2D T[,] , mapeada diretamente para uma Memory2D<T> instância.
• Uma matriz 3D T[,,] , com uma Memory2D<T> instância representando uma determinada fatia de profundidade (uma camada).

O Memory2D<T> tipo também expõe vários métodos de utilidade, incluindo a maior parte da mesma superfície de API que o padrão Memory<T> implementa. Por exemplo, ele inclui um Slice(int, int) método que facilita a realização de operações de fatiamento 2D diretamente no local da memória 2D virtual, com a Memory2D<T> instância ajustando automaticamente os parâmetros necessários internamente para deslocar seu mapeamento na(s) área(s) de memória correta(s) correspondente(s) ao resultado solicitado.

Sintaxe

Veja como você pode criar uma Memory2D<T> instância a partir de uma matriz 2D:

int[,] array =
{
    { 1, 2, 3 },
    { 4, 5, 6 },
    { 7, 8, 9 }
};

Memory2D<int> memory = array;

// The memory directly maps the 2*3 array here

Memory2D<int> slice = memory.Slice(0, 1, 2, 2);

// We create a slice from row 0 and column 1, of size 2*2

int[,] copy = slice.ToArray();

// { 2, 3 }
// { 5, 6 }

// If on a supported runtime, we can also slice using a range

Memory2D<int> test = memory[.., ..2];

// { 1, 2 }
// { 4, 5 }
// { 7, 8 }

Span2D<int> span = memory.Span;

// We can use the span to perform operations on the underlying
// data for the memory instance. All the available APIs are
// documented in the docs about the Span2D<T> type.

ReadOnlyMemory2D<T>

O ReadOnlyMemory2D<T> é para o tipo Memory2D<T> o que ReadOnlyMemory<T> é para Memory<T>. Ele expõe as mesmas funcionalidades exatas (menos as APIs que envolvem a modificação do conteúdo da área de memória encapsulada) e fornece uma visualização somente leitura para locais arbitrários de memória 2D. Para obter mais informações sobre como esse tipo funciona, consulte o parágrafo sobre o Memory2D<T> tipo acima.

Exemplos

Pode encontrar mais exemplos nos testes unitários.