Memory2D<T>

Memory2D<T> è un tipo che rispecchia la funzionalità del Memory<T> tipo, con la differenza che può essere usata per rappresentare percorsi di memoria 2D. È estremamente flessibile ed è in grado di eseguire il wrapping di diversi tipi, tra cui matrici ND (con supporto esplicito per matrici 1D, 2D e 3D) o Memory<T> istanze. Questo tipo deve essere usato insieme al Span2D<T> tipo , nello stesso modo in cui Memory<T> viene usato insieme a Span<T>. Per altre info sulle differenze principali e sugli scenari di casi d'uso di questi due tipi, è possibile leggere questa pagina della documentazione.

API della piattaforma:Memory2D<T>, Span2D<T>, ReadOnlyMemory2D<T>

Funzionamento

Il Memory2D<T> tipo tiene traccia internamente dell'area di memoria 2D mappata tramite un riferimento all'oggetto di cui è stato eseguito il wrapping, ai parametri di altezza e larghezza e a un parametro di inclinazione speciale. L'altezza e la larghezza indicano la lunghezza delle righe e delle colonne nell'area di memoria 2D, mentre il passo indica l'offset tra la fine di ogni riga e l'inizio della riga seguente.

Ecco un semplice diagramma che illustra questa configurazione (le celle "XX" nella griglia rappresentano gli elementi appartenenti all'area di memoria 2D di destinazione):

//                _____________________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__/
// ...________/

Questa configurazione consente di Memory2D<T> essere estremamente flessibile nel modo in cui esegue il mapping dei buffer esistenti alle aree di memoria 2D, in quanto consente anche di rappresentare buffer non contigui come posizione di memoria 2D "virtuale". Ecco ad esempio alcuni esempi di tipi di buffer a cui un'istanza può eseguire il Memory2D mapping:

• Matrice 1D T[] mappata come area di memoria 2D in ordine principale di riga.
• Matrice 2D T[,] mappata direttamente a un'istanza Memory2D<T> di .
• Matrice 3D T[,,] , con un'istanza Memory2D<T> che rappresenta una sezione di profondità specificata (un livello).

Il Memory<T> tipo espone anche diversi metodi di utilità, inclusa la maggior parte della stessa superficie API implementata dallo standard Memory<T> . Ad esempio, include un Slice(int, int) metodo che semplifica l'esecuzione di operazioni di sezionamento 2D direttamente nel percorso di memoria 2D virtuale, con l'istanza Memory2D<T> che regola automaticamente i parametri necessari internamente per spostarne il mapping nell'area di memoria destra corrispondente al risultato richiesto.

Sintassi

Ecco come creare un'istanza Memory2D<T> da una matrice 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>

è ReadOnlyMemory2D<T> del Memory2D<T> tipo che corrisponde ReadOnlyMemory<T> a Memory<T>. Espone le stesse funzionalità esatte (meno le API che comportano la modifica del contenuto dell'area di memoria di cui è stato eseguito il wrapping) e fornisce una visualizzazione di sola lettura a percorsi di memoria 2D arbitrari. Per altre info sul funzionamento di questo tipo, puoi fare riferimento al paragrafo sul Memory2D<T> tipo precedente.

Esempi

Altri esempi sono disponibili negli unit test.