classe 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, consultez les instructions d’utilisation de la mémoire<T>.

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é, les paramètres de hauteur et de largeur, ainsi qu’un paramètre de pas (pitch) 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 ». Voici quelques exemples de types de mémoires tampons auxquels une Memory2D instance peut mapper :

• Un tableau 1D T[] mappé en tant que zone de mémoire 2D avec un ordonnancement par lignes.
• 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 Memory2D<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 inclut une Slice(int, int) méthode qui facilite l’exécution d’opérations de découpage 2D directement sur l’emplacement de mémoire 2D virtuel, avec l’instance Memory2D<T> ajustant automatiquement les paramètres nécessaires en interne pour déplacer son mappage sur 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);

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

ReadOnlyMemory2D<T>

Le type ReadOnlyMemory2D<T> est au type Memory2D<T> ce que ReadOnlyMemory<T> est à 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, consultez le paragraphe précédent sur le Memory2D<T> type.

Exemples

Vous trouverez d’autres exemples dans les tests unitaires.