expressão stackalloc (referência de C#)

Uma stackalloc expressão aloca um bloco de memória na pilha. Um bloco de memória alocado na pilha criado durante a execução do método é descartado automaticamente quando esse método é retornado. Você não pode liberar explicitamente a memória alocada com stackalloc . Um bloco de memória alocado de pilha não está sujeito à coleta de lixo e não precisa ser fixado com uma fixed instrução.

Você pode atribuir o resultado de uma stackalloc expressão a uma variável de um dos seguintes tipos:

  • Começando com o C# 7.2 ou System.Span<T> , como mostra o exemplo a System.ReadOnlySpan<T> seguir:

    int length = 3;
    Span<int> numbers = stackalloc int[length];
    for (var i = 0; i < length; i++)
    {
        numbers[i] = i;
    }
    

    Você não precisa usar um contexto unsafe quando atribui um bloco de memória alocado na pilha a uma variável Span<T> ou ReadOnlySpan<T>.

    Ao trabalhar com esses tipos, você pode usar uma expressão stackalloc em condicional ou expressões de atribuição, como mostra o seguinte exemplo:

    int length = 1000;
    Span<byte> buffer = length <= 1024 ? stackalloc byte[length] : new byte[length];
    

    A partir do C# 8.0, você pode usar uma expressão dentro de outras expressões sempre que uma variável ou é permitida, como mostra o stackalloc exemplo a Span<T> ReadOnlySpan<T> seguir:

    Span<int> numbers = stackalloc[] { 1, 2, 3, 4, 5, 6 };
    var ind = numbers.IndexOfAny(stackalloc[] { 2, 4, 6, 8 });
    Console.WriteLine(ind);  // output: 1
    

    Observação

    É recomendável usar os tipos Span<T> ou ReadOnlySpan<T> sempre que possível para trabalhar com memória alocada na pilha.

  • Um tipo de ponteiro, como mostra o seguinte exemplo:

    unsafe
    {
        int length = 3;
        int* numbers = stackalloc int[length];
        for (var i = 0; i < length; i++)
        {
            numbers[i] = i;
        }
    }
    

    Como mostra o exemplo anterior, você precisa usar um contexto unsafe ao trabalhar com tipos de ponteiro.

    No caso de tipos de ponteiro, você pode usar uma stackalloc expressão somente em uma declaração de variável local para inicializar a variável.

A quantidade de memória disponível na pilha é limitada. Se você alocar muita memória na pilha, um StackOverflowException será lançado. Para evitar isso, siga as regras abaixo:

  • Limite a quantidade de memória alocada com stackalloc . Por exemplo, se o tamanho do buffer pretendido estiver abaixo de um determinado limite, você alocará a memória na pilha; caso contrário, use uma matriz do comprimento necessário, como mostra o código a seguir:

    const int MaxStackLimit = 1024;
    Span<byte> buffer = inputLength <= MaxStackLimit ? stackalloc byte[inputLength] : new byte[inputLength];
    

    Observação

    Como a quantidade de memória disponível na pilha depende do ambiente no qual o código é executado, seja conservadora quando você definir o valor de limite real.

  • Evite usar stackalloc loops de dentro. Aloce o bloco de memória fora de um loop e reutiliza-o dentro do loop.

O conteúdo da memória recém-alocada é indefinido. Você deve inicializá-lo antes do uso. Por exemplo, você pode usar o Span<T>.Clear método que define todos os itens para o valor padrão do tipo T .

A partir do C# 7.3, você pode usar a sintaxe do inicializador de matriz para definir o conteúdo da memória recém-alocada. O seguinte exemplo demonstra várias maneiras de fazer isso:

Span<int> first = stackalloc int[3] { 1, 2, 3 };
Span<int> second = stackalloc int[] { 1, 2, 3 };
ReadOnlySpan<int> third = stackalloc[] { 1, 2, 3 };

Na expressão stackalloc T[E] , deve ser um tipo T nãomanagedo e deve ser avaliada como E um valor int não negativo.

Segurança

O uso de stackalloc habilita automaticamente os recursos de detecção de estouro de buffer no CLR (Common Language Runtime). Se for detectada uma estouro de buffer, o processo será encerrado assim que possível para minimizar a chance de o código mal-intencionado ser executado.

Especificação da linguagem C#

Para obter mais informações, consulte a seção Alocação de pilha da especificação da linguagem C# e a observação da proposta de recurso Permitir em stackalloc contextos aninhados.

Confira também