Memory2D<T>

Memory2D<T> är en typ som speglar funktionen för Memory<T> typen, med skillnaden att den kan användas för att representera 2D-minnesplatser. Den är extremt flexibel och kan omsluta ett antal olika typer, inklusive ND-matriser (med uttryckligt stöd för 1D-, 2D- och 3D-matriser) eller Memory<T> instanser. Den här typen är avsedd att användas tillsammans med Span2D<T> typen på samma sätt som Memory<T> används tillsammans med Span<T>. Mer information om de viktigaste skillnaderna och användningsfallen för dessa två typer finns på den här dokumentsidan.

Plattforms-API:er:Memory2D<T>, Span2D<T>, ReadOnlyMemory2D<T>

Så här fungerar det

Typen Memory2D<T> spårar internt det mappade 2D-minnesområdet genom en referens till det omslutna objektet, parametrarna för höjd och bredd och en speciell tonhöjdsparameter. Höjden och bredden anger längden på raderna och kolumnerna i 2D-minnesområdet, medan tonhöjden anger förskjutningen mellan slutet av varje rad och början av följande.

Här är ett enkelt diagram som illustrerar den här konfigurationen ("XX"-cellerna i rutnätet representerar objekt som tillhör mål-2D-minnesområdet):

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

Den här konfigurationen gör det möjligt Memory2D<T> att vara extremt flexibel på det sätt som den mappar befintliga buffertar till 2D-minnesområden, eftersom det gör det möjligt att också representera osammanhängande buffertar som en "virtuell" 2D-minnesplats. Här är till exempel några exempel på bufferttyper som en Memory2D instans kan mappa till:

• En 1D-matris T[] som mappas som ett 2D-minnesområde i radmajorordning.
• En 2D-matris T[,] som mappas direkt till en Memory2D<T> instans.
• En 3D-matris T[,,] med en Memory2D<T> instans som representerar en viss djupsektor (ett lager).

Typen Memory2D<T> exponerar också ett antal verktygsmetoder, inklusive de flesta av samma API-yta som standarden Memory<T> implementerar. Den innehåller till exempel en Slice(int, int) metod som gör det enkelt att utföra 2D-segmenteringsåtgärder direkt på den virtuella 2D-minnesplatsen, där instansen Memory2D<T> automatiskt justerar de parametrar som krävs internt för att flytta mappningen på rätt minnesyta som motsvarar det begärda resultatet.

Syntax

Så här kan du skapa en Memory2D<T> instans från en 2D-matris:

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> är för Memory2D<T> typen vad ReadOnlyMemory<T> är för Memory<T>. Den exponerar samma exakta funktioner (minus API:erna som innebär att innehållet i det omslutna minnesområdet ändras) och ger en skrivskyddad vy till godtyckliga 2D-minnesplatser. Mer information om hur den här typen fungerar finns i stycket om Memory2D<T>-typen ovan.

Exempel

Du kan hitta fler exempel i enhetstesterna .