C# - Apresentando a classe Buffer

C# - Apresentando a classe Buffer

Hoje vamos apresentar a classe Buffer do C# que pode ser usada para manipular matrizes de tipos primitivos.

Um buffer é uma sequência de bytes na memória e buffering é a manipulação dos dados que residem na memória. Na plataforma .NET, o buffering refere-se à manipulação da memória não gerenciada, que é representada como uma matriz de bytes.

Podemos aproveitar a classe System.Buffer na plataforma .NET sempre que precisarmos gravar dados na memória diretamente ou sempre que desejarmos manipular dados armazenados em memória não gerenciada.

A classe Buffer afeta apenas matrizes de tipos primitivos e não se aplica a objetos. Cada tipo primitivo é tratado como uma série de bytes sem considerar qualquer comportamento ou limitação associada ao tipo primitivo.

Esta classe fornece métodos para copiar bytes de uma matriz de tipos primitivos para outra matriz de tipos primitivos, obter um byte de uma matriz, definir um byte em uma matriz e obter o comprimento de uma matriz.

Nota: Essa classe fornece melhor desempenho para manipular tipos primitivos do que métodos semelhantes na classe System.Array .

A seguir alguns dos principais métodos da classe Buffer:

BlockCopy(Array, Int32, Array, Int32) - É usado para copiar uma matriz de origem de um deslocamento especificado para uma matriz de destino em um deslocamento especificado;
ByteLength(Array) - Retorna o número total de bytes em um array, ou seja, o comprimento do array;
GetByte(Array, Int32) - É usado para recuperar um byte em um local especificado em uma matriz;
SetByte(Array, Int32, Byte) - É usado para definir um byte em um determinado local na matriz;
MemoryCopy(Void*, Void*, Int64, Int64) e MemoryCopy(Void*, Void*, UInt64, UInt64) - São usados para copiar um número de bytes de um endereço de origem na memória para outro endereço.

Abaixo temos um exemplo de código com uma aplicação Console no .NET 6 onde são usados os principais métodos da classe Buffer.

// Esta matriz será modificada e exibidas
short[] matriz = { 258, 259, 260, 261, 262, 263, 264, 265,
266, 267, 268, 269, 270, 271 };

Console.WriteLine("Exemplo de uso dos métodos classe Buffer \n");
Console.WriteLine("Valores iniciais no array array:\n");

// Exibe os valores do array inicial e o ByteLength.
ExibeArray(matriz);

Console.WriteLine($"\nBuffer.ByteLength( array ):
{Buffer.ByteLength(matriz)}");

// Copia uma região do array; defin o byte dentro do array.
Console.WriteLine("\nChama os métodos: \n" +
" Buffer.BlockCopy( array, 5, array, 16, 9 ),\n" +
" Buffer.SetByte( arrary, 7, 170 ).\n");

Buffer.BlockCopy(matriz, 5, matriz, 16, 9);
Buffer.SetByte(matriz, 7, 170);

// Exibe o array o byte dentro do array.
Console.WriteLine("Valores finais do array:\n");

ExibeArray(matriz);

Console.WriteLine($"\nBuffer.GetByte( array, 26 ):
{ Buffer.GetByte(matriz, 26)}");

Console.ReadKey();

void ExibeArray(short[] array)
{
    Console.Write(" array:");
    for (int x = array.Length - 1; x >= 0; x--)
    {
        Console.Write(" {0:X4}", array[x]);
    }
    Console.WriteLine();
}

A seguir o resultado da execução deste código:

Note que podemos aproveitar o método Buffer.BlockCopy para copiar bytes entre uma matriz de origem e uma matriz de destino, conforme mostrado no exemplo acima.

Também podemos usar o método ByteLength para descobrir o tamanho do array.

E os métodos SetByte e GetByte da classe Buffer podem ser usados para definir ou ler bytes individuais de e para uma matriz, respectivamente.

Dessa forma a classe Buffer oferece um desempenho muito melhor ao manipular uma região de memória que contém tipos primitivos. Você deve aproveitar a classe Buffer sempre que precisar manipular dados na memória e também sempre que precisar de acesso rápido aos dados armazenados na memória.

Pegue o projeto aqui: CShp_Buffer.zip

"Jesus, porém, olhando para eles, disse: Para os homens é impossível, mas não para Deus, porque para Deus todas as coisas são possíveis."
Marcos 10:27

Referências:

José Carlos Macoratti