Classe Memory2D<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 mais informações sobre as principais diferenças e cenários de uso destes dois tipos, consulte as diretrizes de utilização da Memória<T>.

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". Seguem-se alguns exemplos de tipos de buffer para os quais uma Memory2D instância pode mapear:

• Um array 1D T[] mapeado como uma área 2D de memória em ordem major de linhas.
• 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, inclui um Slice(int, int) método que facilita realizar operações de fatiamento 2D diretamente na localização virtual da memória 2D, em que a Memory2D<T> instância ajusta automaticamente os parâmetros necessários internamente para deslocar o seu mapeamento nas áreas de memória adequadas correspondentes 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);

// 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, you can also slice using a range:
Memory2D<int> test = memory[.., ..2];

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

Span2D<int> span = memory.Span;

// You 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.

LeituraApenaMemória2D<T>

O tipo ReadOnlyMemory2D<T> é para o tipo Memory2D<T> aquilo 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 mais informações sobre como este tipo funciona, consulte o parágrafo anterior sobre o Memory2D<T> tipo.

Exemplos

Pode encontrar mais exemplos nos testes unitários.