C# Language stackalloc


Esempio

La parola chiave stackalloc crea una regione di memoria nello stack e restituisce un puntatore all'inizio di tale memoria. La memoria allocata nello stack viene automaticamente rimossa quando viene chiuso l'ambito in cui è stato creato.

//Allocate 1024 bytes. This returns a pointer to the first byte.
byte* ptr = stackalloc byte[1024];

//Assign some values...
ptr[0] = 109;
ptr[1] = 13;
ptr[2] = 232;
...

Utilizzato in un contesto non sicuro.

Come con tutti i puntatori in C # non ci sono limiti di controllo su letture e compiti. La lettura oltre i limiti della memoria allocata avrà risultati imprevedibili - potrebbe accedere a qualche posizione arbitraria all'interno della memoria o potrebbe causare un'eccezione di violazione di accesso.

//Allocate 1 byte
byte* ptr = stackalloc byte[1];

//Unpredictable results...
ptr[10] = 1;
ptr[-1] = 2;

La memoria allocata nello stack viene automaticamente rimossa quando viene chiuso l'ambito in cui è stato creato. Ciò significa che non si dovrebbe mai restituire la memoria creata con stackalloc o conservarla oltre la durata dell'ambito.

unsafe IntPtr Leak() {
    //Allocate some memory on the stack
    var ptr = stackalloc byte[1024];

    //Return a pointer to that memory (this exits the scope of "Leak")
    return new IntPtr(ptr);
}

unsafe void Bad() {
     //ptr is now an invalid pointer, using it in any way will have
     //unpredictable results. This is exactly the same as accessing beyond
     //the bounds of the pointer.
     var ptr = Leak();
}

stackalloc può essere usato solo quando si dichiarano e si inizializzano variabili. Quanto segue non è valido:

byte* ptr;
...
ptr = stackalloc byte[1024];

Osservazioni:

stackalloc deve essere usato solo per ottimizzare le prestazioni (sia per il calcolo che per l'interoperabilità). Ciò è dovuto al fatto che:

  • Il garbage collector non è necessario in quanto la memoria viene allocata nello stack piuttosto che nell'heap - la memoria viene rilasciata non appena la variabile esce dallo scope
  • È più veloce allocare memoria nello stack anziché nell'heap
  • Aumentare la possibilità di colpi di cache sulla CPU a causa della località dei dati