Memory2D<T>

Memory2D<T> est un type qui reflète les fonctionnalités du type Memory<T>, à la différence qu’il peut être utilisé pour représenter des emplacements de mémoire 2D. Il est extrêmement flexible et capable d’encapsuler un certain nombre de types différents, notamment des tableaux ND (avec une prise en charge explicite des tableaux 1D, 2D et 3D) ou des instances Memory<T>. Ce type est destiné à être utilisé avec le type Span2D<T>, de la même façon que Memory<T> est utilisé avec Span<T>. Pour plus d’informations sur les principales différences et les scénarios de cas d’usage de ces deux types, vous pouvez consulter cette page de documentation.

API de plateforme : Memory2D<T>, Span2D<T>, ReadOnlyMemory2D<T>

Fonctionnement

Le type Memory2D<T> assure en interne le suivi de la zone de mémoire 2D mappée via une référence à l’objet encapsulé, aux paramètres de hauteur et de largeur et à un paramètre de pas spécial. La hauteur et la largeur indiquent la longueur des lignes et des colonnes dans la zone de mémoire 2D, tandis que le pas indique le décalage entre la fin de chaque ligne et le début de la suivante.

Voici un diagramme simple qui illustre cette configuration (les cellules « XX » contenues dans la grille représentent les éléments appartenant à la zone de mémoire 2D cible) :

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

Cette configuration permet à Memory2D<T> d’être extrêmement flexible dans sa façon de mapper les tampons existants aux zones de mémoire 2D, car cela permet également de représenter les tampons non contigus en tant qu’emplacement de mémoire 2D « virtuelle ». Par exemple, voici quelques exemples de types de tampons auxquels une instance Memory2D peut se mapper :

• Tableau T[] 1D mappé en tant que zone de mémoire 2D dans l’ordre row-major.
• Tableau T[,] 2D, mappé directement à une instance Memory2D<T>.
• Tableau T[,,] 3D, avec une instance Memory2D<T> représentant une tranche de profondeur donnée (couche).

Le type Memory<T> expose également un certain nombre de méthodes utilitaires, dont l’essentiel de la surface d’API implémentée par l’instance Memory<T> standard. Par exemple, il comporte une méthode Slice(int, int) qui facilite l’exécution d’opérations de découpage 2D directement à l’emplacement de la mémoire 2D virtuelle, où l’instance Memory2D<T> ajuste automatiquement les paramètres nécessaires en interne pour déplacer son mappage dans la ou les zones de mémoire appropriées correspondant au résultat demandé.

Syntaxe

Voici comment vous pouvez créer une instance Memory2D<T> à partir d’un tableau 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> est au type Memory2D<T> ce que ReadOnlyMemory<T> est au type Memory<T>. Il expose exactement les mêmes fonctionnalités (sans les API qui impliquent la modification du contenu de la zone de mémoire encapsulée) et offre une vue en lecture seule des emplacements de mémoire 2D arbitraires. Pour plus d’informations sur le fonctionnement de ce type, vous pouvez vous reporter au paragraphe qui traite du type Memory2D<T> ci-dessus.

Exemples

Vous trouverez d’autres exemples dans les tests unitaires.