Span2D<T>

Span2D<T> es un tipo que imita la funcionalidad del tipo Span<T>, pero admite regiones de memoria 2D. Igual que Memory2D<T>, es extremadamente flexible y puede encapsular una serie de objetos diferentes, así como punteros nativos o referencias de GC.

El diseño interno es similar al que usa el tipo Memory2D<T>, incluido un parámetro de inclinación que se usa para habilitar la compatibilidad con búferes de memoria no contiguos. Puede leer más información al respecto en la documentación sobre Memory2D<T>.

API de la plataforma: Span2D<T>, Memory2D<T>, ReadOnlySpan2D<T>

Sintaxis

Aquí se muestra cómo puede crear una instancia de Span2D<T> a partir de una matriz 2D:

int[,] array =
{
    { 1, 2, 3 },
    { 4, 5, 6 }
};

Span2D<int> span = array;

// The memory directly maps the 2*3 array here

span[0, 0] = 10;
span[2, 1] = 20;

// The array is now:
// { 10, 2, 3 },
// { 4, 20, 6 }

// We can also use indices, on supported runtimes
int x = span[0, ^1];

// We can also get references to items, like with arrays
ref int reference = ref span[1, 1];

Span2D<int> slice = span.Slice(0, 1, 2, 2);

// Or alternatively, on supported runtimes

slice = span[.., 1..];

int[,] copy = slice.ToArray();

// The resulting array is:
// { 2, 3 },
// { 20, 6 }

También puede crear directamente una vista 2D sobre la memoria nativa:

int* p = stackalloc int[9];

Span2D<int> span = new Span2D<int>(p, 3, 3);

El tipo Span2D<T> también incluye tipos de enumerador personalizados para recorrer fácilmente una fila, una columna o toda el área de memoria usando la sintaxis foreach estándar en C#, así como realizando operaciones masivas en una sola llamada:

int[,] array =
{
    { 1, 2, 3 },
    { 4, 5, 6 },
    { 7, 8, 9 }
};

Span2D<int> span = array;

foreach (int i in span.GetColumn(1))
{
    // 2, 5, 8
}

// We can also iterate by reference
foreach (ref int i in span.GetRow(2))
{
    // 7, 8, 9
}

foreach (int i in span)
{
    // 1, 2, 3, 4, 5...
}

// Set all items in a column to 0
span.GetColumn(0).Clear();

// Set the value of all items in a row
span.GetRow(1).Fill(42);

Span<int> copy = stackalloc int[3];

// Copy all items from a column
span.GetColumn(2).CopyTo(copy);

// Get a copy of a row as an array
int[] array = span.GetRow(1).ToArray();

ReadOnlySpan2D<T>

ReadOnlySpan2D<T> es para el tipo Span2D<T> lo mismo que ReadOnlySpan<T> es para Span<T>. Expone un conjunto similar de API, pero no proporciona ninguna manera de modificar directamente el contenido del área de memoria subyacente.

Código de ejemplo

Puede encontrar más ejemplos en las pruebas unitarias.