stackalloc (C#-Referenz)stackalloc (C# Reference)

Das Schlüsselwort stackalloc wird in unsicherem Codekontext verwendet, um dem Stapel einen Speicherblock zuzuweisen.The stackalloc keyword is used in an unsafe code context to allocate a block of memory on the stack.

int* block = stackalloc int[100];

HinweiseRemarks

Das Schlüsselwort ist nur in lokalen Variableninitialisierern gültig.The keyword is valid only in local variable initializers. Folgender Code verursacht Compilerfehler.The following code causes compiler errors.

int* block;
// The following assignment statement causes compiler errors. You
// can use stackalloc only when declaring and initializing a local
// variable.
block = stackalloc int[100];

Ab C# 7.3 können Sie die Syntax des Arrayinitialisierers für stackalloc-Arrays verwenden.Beginning with C# 7.3, you can use array initializer syntax for stackalloc arrays. Alle nachfolgenden Deklarationen deklarieren ein Array mit drei Elementen, dessen Werte die ganzen Zahlen 1, 2 und 3 darstellen:All the following declarations declare an array with three elements whose values are the integers 1, 2, and 3:

// Valid starting with C# 7.3
int* first = stackalloc int[3] { 1, 2, 3 };
int* second = stackalloc int[] { 1, 2, 3 };
int* third = stackalloc[] { 1, 2, 3 };

Da Zeigertypen beteiligt sind, benötigt stackalloc einen unsafe-Kontext.Because pointer types are involved, stackalloc requires an unsafe context. Weitere Informationen finden Sie unter Unsicherer Code und Zeiger.For more information, see Unsafe Code and Pointers

Genau wie _alloca befindet sich stackalloc in der C-Laufzeitbibliothek.stackalloc is like _alloca in the C run-time library.

BeispieleExamples

Im folgenden Beispiel werden die ersten 20 Zahlen der Fibonacci-Folge berechnet und angezeigt.The following example calculates and displays the first 20 numbers in the Fibonacci sequence. Jede Zahl bildet die Summe der beiden vorherigen Zahlen.Each number is the sum of the previous two numbers. Im Code wird dem Stapel, nicht dem Heap, ein Speicherblock zugewiesen, der groß genug ist, um 20 Elemente vom Typ int zu enthalten.In the code, a block of memory of sufficient size to contain 20 elements of type int is allocated on the stack, not the heap. Die Adresse des Blocks wird im Zeiger fib gespeichert.The address of the block is stored in the pointer fib. Dieser Speicher unterliegt nicht der automatischen Speicherbereinigung und muss daher nicht (mithilfe von fixed) angeheftet werden.This memory is not subject to garbage collection and therefore does not have to be pinned (by using fixed). Die Lebensdauer des Speicherblocks ist auf die Lebensdauer der definierenden Methode begrenzt.The lifetime of the memory block is limited to the lifetime of the method that defines it. Sie können den Speicher nicht freigeben, bevor die Methode zurückgibt.You cannot free the memory before the method returns.

const int arraySize = 20;
int* fib = stackalloc int[arraySize];
int* p = fib;
// The sequence begins with 1, 1.
*p++ = *p++ = 1;
for (int i = 2; i < arraySize; ++i, ++p)
{
    // Sum the previous two numbers.
    *p = p[-1] + p[-2];
}
for (int i = 0; i < arraySize; ++i)
{
    Console.WriteLine(fib[i]);
}
/* Output:
   1
   1
   2
   3
   5
   8
   13
   21
   34
   55
   89
   144
   233
   377
   610
   987
   1597
   2584
   4181
   6765
 */

Im folgenden Beispiel wird ein stackalloc-Array von ganzen Zahlen in eine Bitmaske initialisiert, für die in jedem Element ein Bit festgelegt ist.The following example initializes a stackalloc array of integers to a bit mask with one bit set in each element. Dies stellt die neue Syntax des Initialisierers dar, die ab C# 7.3 verfügbar ist.This demonstrates the new initializer syntax available starting in C# 7.3:

int* mask = stackalloc[] {
    0b_0000_0000_0000_0001,
    0b_0000_0000_0000_0010,
    0b_0000_0000_0000_0100,
    0b_0000_0000_0000_1000,
    0b_0000_0000_0001_0000,
    0b_0000_0000_0010_0000,
    0b_0000_0000_0100_0000,
    0b_0000_0000_1000_0000,
    0b_0000_0001_0000_0000,
    0b_0000_0010_0000_0000,
    0b_0000_0100_0000_0000,
    0b_0000_1000_0000_0000,
    0b_0001_0000_0000_0000,
    0b_0010_0000_0000_0000,
    0b_0100_0000_0000_0000,
    0b_1000_0000_0000_0000
};

for (int i = 0; i < 16; i++)
    Console.WriteLine(mask[i]);
/* Output:
   1
   2
   4
   8
   16
   32
   64
   128
   256
   512
   1024
   2048
   4096
   8192
   16384
   32768
 */

SicherheitSecurity

Unsicherer Code ist unsicherer als sichere Alternativen.Unsafe code is less secure than safe alternatives. Allerdings werden mit der Verwendung von stackalloc automatisch Funktionen zum Erkennen eines Pufferüberlaufs in der Common Language Runtime (CLR) aktiviert.However, the use of stackalloc automatically enables buffer overrun detection features in the common language runtime (CLR). Wenn ein Pufferüberlauf erkannt wird, wird der Vorgang so schnell wie möglich beendet, damit das Risiko der Ausführung von schädlichem Code verringert wird.If a buffer overrun is detected, the process is terminated as quickly as possible to minimize the chance that malicious code is executed.

C#-ProgrammiersprachenspezifikationC# Language Specification

Weitere Informationen erhalten Sie unter C#-Sprachspezifikation.For more information, see the C# Language Specification. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.The language specification is the definitive source for C# syntax and usage.

Siehe auchSee Also

C#-ReferenzC# Reference
C#-ProgrammierhandbuchC# Programming Guide
C#-SchlüsselwörterC# Keywords
OperatorschlüsselwörterOperator Keywords
Unsicherer Code und ZeigerUnsafe Code and Pointers