comportamento non chiara di un puntatore fisso al di fuori della dichiarazione fisso

Question

Qualcuno mi può spiegare perché il codice qui sotto C # non va in crash? Perché Visual Studio in realtà permette di compilarlo? La mia comprensione è che sto ottenendo un puntatore fisso, ma si fissa solo all'interno dell'istruzione 'fissa'. Quando il puntatore viene restituita dalla funzione 'Foo', l'array 'ar' possono essere raccolte. Ho quindi forzare GC di fare effettivamente questo, ma la scrittura consecutiva alla memoria (che ora è deallocata) non causa alcun errore.

class Program
{
    static unsafe byte* Foo()
    {
        byte[] ar = new byte[100];
        fixed (byte* ptr = ar)
        {
            return ptr;
        }
    }

    static unsafe void Main(string[] args)
    {
        byte* ptr = Foo();
        GC.Collect();
        for (int t = 0;;++t) ptr[t%100] = 0;
    }
}

Answer 1

Eric ha ragione, ma la risposta probabilmente avrete bisogno di sentire è che "a volte è utile per mantenere l'indirizzo al di fuori della dichiarazione fisso".

Forse il ricordo di quel puntatore è già fissato da un'altra dichiarazione fissa da qualche altra parte, e ha senso di restituirlo? Il compilatore non sta cercando di indovinare voi e dare avvertimenti rumorosi.

Detto questo, mi auguro che CodeAnalysis o altri strumenti avanzati avrebbero intervenire qui dove il compilatore è che ti permette di tagliare fuori il proprio piede.

Answer 2

Solo perché la memoria viene liberata non significa che la scrittura avrebbe causato un errore di qualsiasi tipo. Quando il garbage collector recupera la memoria, solo che lo contrassegna come libero nella sua mappa di memoria interna -. Non dà di nuovo al sistema operativo subito, quindi è ancora memoria valida per il vostro processo di usare

Naturalmente, utilizzando un puntatore al di fuori del blocco fisso perché è un molto cattiva idea -. Non pratico