DEV Community: Pedro

Inline arrays no c# - alocando arrays na stack

Pedro — Thu, 19 Mar 2026 19:21:01 +0000

Antes do c# 12, para criar um array na stack era preciso usar o stackalloc:

Span<int> array = stackalloc int[10];

Com o c# 12, é possível criar um array na stack usando uma annotation em uma struct

[InlineArray(10)]
public struct MeuArrayNaStack
{
    private int _elemento; 
}

para usar:

MeuArrayNaStack array = new MeuArrayNaStack();

for (int i = 0; i < 10; i++)
{
    array[i] = i * 2;
}

Examinando o IL gerado (apenas pontos relevantes)

Na alocação tracional, que acontece na heap, temos:

IL_0000: ldc.i4 1000
IL_0005: newarr [System.Runtime]System.Int32

No stackalloc, temos:

IL_0000: ldc.i4 4000 #calculo 1000 elementos * 4 bytes por int
IL_0005: conv.u
IL_0006: localloc

No uso do InlineArray, temos:

IL_0000: ldloca.s 0
IL_0002: initobj MeuArrayFixoGrande

Aqui ele nao aloca um array, mas sim uma struct que tem o mesmo tamanho de um array de 1000 elementos. O acesso aos elementos é feito através de indexação, mas internamente ele trata a struct como um bloco de memória contíguo, similar a um array.

O compilador ve que na struct foi colocado o InlineArray e coloca no final:

.class private auto ansi sealed '<PrivateImplementationDetails>'

ou seja, o compilador cria uma classe interna para o usar o comportamento de array em uma struct.

Exemplo:

Ao acessar array[500] = 99 o compilador nao acessa o array tradicional, ele intercepta e redireciona para um método gerado nessa PrivateImplementationDetails que calcula o offset e acessa a struct como um bloco de memória contíguo, similar a um array.
Ao tentar iterar o array, o compilador usa o outro método InlineArrayAsSpan, que pega a struct (o bloco contíguo de 4000 bytes na stack) e envelopa dentro de um Span<int>, permitindo iterar sobre ele como se fosse um array tradicional.

Comparando benchmarks

Usando o seguinte código de benchmark:

using System.Runtime.CompilerServices;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[InlineArray(1000)]
public struct MeuArrayFixoGrande
{
    private int _elemento;
}

[MemoryDiagnoser] 
public class ArrayBenchmarks
{
    [Benchmark(Baseline = true)]
    public int ArrayTradicionalHeap()
    {
        // Tamanho 1000 para evitar que o compilador otimize e acabe alocando na Stack mesmo
        int[] array = new int[1000];
        for (int i = 0; i < 1000; i++) array[i] = i;
        return array[500];
    }

    [Benchmark]
    public int ArrayStackAlloc()
    {
        Span<int> array = stackalloc int[1000];
        for (int i = 0; i < 1000; i++) array[i] = i;
        return array[500];
    }

    [Benchmark]
    public int UsoInlineArray()
    {
        var array = new MeuArrayFixoGrande();
        for (int i = 0; i < 1000; i++) array[i] = i;
        return array[500];
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        BenchmarkRunner.Run<ArrayBenchmarks>();
    }
}

Tabela de resultados:

Método	Media	Margem de erro	Desvio padrão	Proporção	Desvio padrão da Proporção	Gen0	Alocado	Proporção de alocação
ArrayTradicionalHeap	465.8 ns	9.28 ns	9.93 ns	1.00	0.03	0.9613	4024 B	1.00
ArrayStackAlloc	303.4 ns	6.06 ns	5.66 ns	0.65	0.02	-	-	0.00
UsoInlineArray	310.1 ns	6.06 ns	7.66 ns	0.67	0.02	-	-	0.00

Resultado em gráfico:

Análise dos resultados

O benchmark mostra que tanto o uso de stackalloc quanto o uso de InlineArray resultam em um desempenho significativamente melhor do que a alocação tradicional de arrays no heap. O stackalloc tem uma leve vantagem sobre o InlineArray, mas ambos são muito mais rápidos do que a alocação no heap.

Além disso, ambos stackalloc e InlineArray não alocam memória no heap, o que é evidenciado pela ausência de alocação de memória reportada no benchmark. Isso pode levar a uma redução significativa na pressão do garbage collector e melhorar o desempenho geral da aplicação, especialmente em cenários onde muitos arrays são criados e descartados rapidamente.

Em um cenário real de desenvolvimento corporativo, quase nunca seria necessário usar stackalloc ou InlineArray para arrays tão grandes quanto 1000 elementos, mas o benchmark serve para ilustrar a diferença de desempenho entre as abordagens. Para arrays menores, a diferença de desempenho pode ser ainda mais significativa, tornando essas técnicas uma escolha valiosa para otimizar o desempenho em situações críticas.

Base64 - matemática e C#

Pedro — Thu, 19 Mar 2026 19:19:27 +0000

Encoding vs hashing

Base 64 e os outros "bases" citados são uma forma de encoding, isso é, transformar um dado em uma sequencia de caracteres, diferente de hashing que é uma função unidirecional, ou seja, não é possível recuperar o dado original a partir do hash.

Com isso, também é nítido que são usados para propósitos diferentes, o encoding é usado geralmente para transmitir dados, enquanto o hashing é usado para verificar a integridade dos dados ou para armazenar senhas de forma segura.

Como similaridade, ambas são determinísticas, ou seja, o mesmo dado de entrada sempre resultará no mesmo resultado.

Princípios matemáticos de hashing e encoding

Encoding

O encoding pode ser representado matematicamente como uma função $\to B$ , onde $A$ é o conjunto de dados originais e $B$ é o conjunto de dados codificados. O encoding é invertível (bijetor), ou seja:

\exists f^{-1} : B \to A \mid f^{-1}(f(x)) = x, \quad \forall x \in A

Em outras palavras, existe uma função inversa $f^{-1}$ que, quando aplicada ao resultado de $f$ , recupera o dado original $x$ de forma íntegra. Portanto, a relação entre $f$ e $f^{-1}$ é de identidade: $f^{-1}(f(x)) = x$ para todo $x$ em $A$ .

Hashing

O hashing pode ser representado matematicamente como uma função $\to B$ , onde $A$ é o conjunto de dados originais e $B$ é o conjunto de hashes. O hashing é unidirecional (one-way), o que implica que não existe uma função inversa capaz de reverter o processo para todos os elementos:

\nexists f : B \to A \mid f(h(x)) = x, \quad \forall x \in A

Diferente do encoding, o hashing não é uma função injetora. Como o conjunto de destino $B$ é finito e geralmente menor que o conjunto de origem $A$ ( $∣ B ∣ < ∣ A ∣$ ), aplica-se o Princípio da Casa dos Pombos, permitindo a existência de colisões:

\exists x_1, x_2 \in A \mid x_1 \neq x_2 \land h(x_1) = h(x_2)

Portanto, a operação de inversão é logicamente impossível, pois um único hash $\in B$ pode estar associado a múltiplos valores de origem em $A$ , tornando a recuperação do dado original $x$ ambígua e computacionalmente inviável.

Base 64

Base 64 é um sistema de codificação que representa dados binários em formato de texto usando um conjunto de 64 caracteres. Ele é amplamente utilizado para transmitir dados binários, como imagens, arquivos e outros tipos de dados, em formatos que só aceitam texto, como e-mails e URLs.

É chamado de 64, pois existem 64 caracteres possíveis para representar os dados codificados. Cada caractere representa um valor de 6 bits, o que significa que cada grupo de 3 bytes (24 bits) é codificado em 4 caracteres de base 64.

Os caracteres são:

Letras maiúsculas (A-Z)
Letras minúsculas (a-z)
Dígitos (0-9)
Símbolos (+ e /)

Matematicamente, temos:

\frac{24 \text{ bits}}{8 \text{ bits/byte}} = 3 \text{ bytes}

\frac{24 \text{ bits}}{6 \text{ bits/caractere}} = 4 \text{ caracteres}

E isso explica o aumento de 33% no tamanho dos dados codificados em base 64, já que cada grupo de 3 bytes é representado por 4 caracteres.

Uso em c

Imagine o cenário onde você tem um arquivo de imagem e deseja transmiti-lo por algum canal que só aceite texto. Você pode usar o base 64 para codificar o arquivo de imagem em uma string de texto, que pode ser facilmente transmitida e depois decodificada para recuperar a imagem original.

string imagePath = "caminho/para/sua/imagem.jpg";

byte[] imageBytes = File.ReadAllBytes(imagePath);

//checar o tamanho do arquivo
Console.WriteLine($"Tamanho do arquivo original: {imageBytes.Length} bytes");

string base64String = Convert.ToBase64String(imageBytes);

//checar o tamanho do arquivo codificado
Console.WriteLine($"Tamanho do arquivo codificado: {base64String.Length} caracteres");

Console.WriteLine("Imagem codificada em Base 64:");
Console.WriteLine(base64String);

//razao de aumento de tamanho
double increaseRatio = (double)base64String.Length / imageBytes.Length;
Console.WriteLine($"Aumento de tamanho: {increaseRatio:P2}");

byte[] decodedBytes = Convert.FromBase64String(base64String);

File.WriteAllBytes("caminho/para/sua/imagem_decodificada.jpg", decodedBytes);

Base 64 na URL

Base 64 URL é uma variação do base 64 que é projetada para ser segura para uso em URLs e nomes de arquivos. Ele substitui os caracteres '+' e '/' por '-' e '_', respectivamente, para evitar problemas de codificação em URLs.

Isso é, se usássemos o base 64 normal em uma URL, os caracteres '+' e '/' poderiam ser interpretados de forma errada, causando problemas na transmissão dos dados. Com a base 64 URL, esses caracteres são substituídos por '-' e '_', garantindo que a string codificada seja segura para uso em URLs.

O .NET 9 introduziu suporte nativo para base 64 URL, o que facilita a codificação e decodificação de dados usando esse formato.

string imagePathUrl = "dummy.jpg";
byte[] imageBytesUrl = File.ReadAllBytes(imagePathUrl);

string base64UrlString = Base64Url.EncodeToString(imageBytes);

Console.WriteLine($"Tamanho original: {imageBytes.Length} bytes");
Console.WriteLine($"Tamanho Base64Url: {base64UrlString.Length} caracteres");

//razao de aumento de tamanho
double increaseRatioUrl = (double)base64UrlString.Length / imageBytesUrl.Length;
Console.WriteLine($"Aumento de tamanho do base64Url: {increaseRatio:P2}");

// 2. Decodificar
byte[] decodedUrlBytes = Base64Url.DecodeFromChars(base64UrlString);

File.WriteAllBytes("imagem_url.jpg", decodedUrlBytes);

Outras bases

Além do base 64 e base 64 URL, existem outras variações de codificação em diferentes bases, como base 62, base 58, entre outras. Cada uma delas tem suas próprias características e usos específicos, dependendo do contexto em que são aplicadas.

Base 62

O base62, por exemplo, é uma variação que utiliza um conjunto de 62 caracteres (letras maiúsculas, minúsculas e dígitos) para codificar dados. Ele pode ser usado em situações onde se deseja uma representação mais compacta do que o base 64, mas ainda assim legível e fácil de transmitir.

Base 58

Já o base 58 é uma variação que utiliza um conjunto de 58 caracteres (letras maiúsculas, minúsculas e dígitos, mas sem os caracteres '0', 'O', 'I' e 'l' para evitar confusões) para codificar dados. Ele é frequentemente usado em sistemas de criptomoedas para representar endereços de carteira de forma mais compacta e legível, evitando caracteres que possam ser confundidos visualmente.

Base 85

O base 85 é outra variação que utiliza um conjunto de 85 caracteres para codificar dados. Ele é mais eficiente do que o base 64 em termos de compactação, mas pode ser menos legível e mais difícil de transmitir em alguns contextos.