Istruzione fixed (Riferimenti per C#)

Aggiornamento: novembre 2007

L'istruzione fixed impedisce che il Garbage Collector esegua la rilocazione di una variabile mobile. L'istruzione fixed è consentita soltanto in un contesto unsafe. Fixed può essere utilizzata anche per creare buffer di dimensione fissa.

L'istruzione fixed imposta un puntatore a una variabile gestita e blocca quest'ultima durante l'esecuzione dell'istruzione. Senza l'istruzione fixed, i puntatori alle variabili gestite mobili risulterebbero poco utili poiché la procedura di Garbage Collection potrebbe eseguire una rilocazione delle variabili in qualsiasi momento. Il compilatore C# consente di assegnare un solo puntatore a una variabile gestita in un'istruzione fixed.

unsafe static void TestMethod()
{

    // assume class Point { public int x, y; }
    // pt is a managed variable, subject to garbage collection.
    Point pt = new Point();

    // Using fixed allows the address of pt members to be
    // taken, and "pins" pt so it isn't relocated.

    fixed (int* p = &pt.x)
    {
        *p = 1;
    }        

}

È possibile inizializzare un puntatore con l'indirizzo di una matrice o di una stringa, ad esempio:

unsafe void Test2()
{
    Point point = new Point();
    double[] arr = { 0, 1.5, 2.3, 3.4, 4.0, 5.9 };
    string str = "Hello World";

    fixed (double* p = arr) { /*...*/ }   // equivalent to p = &arr[0]
    fixed (char* p = str) { /*...*/ }  // equivalent to p = &str[0]

    fixed (int* p1 = &point.x)
    {
        fixed (double* p2 = &arr[5])
        {
            // Do something with p1 and p2.
        }
    }

}

È possibile inizializzare più puntatori purché siano tutti dello stesso tipo, ad esempio:

fixed (byte* ps = srcarray, pd = dstarray) {...}

Per inizializzare puntatori di tipo diverso, è sufficiente nidificare le istruzioni fixed:

fixed (int* p1 = &point.x)
{
    fixed (double* p2 = &arr[5])
    {
        // Do something with p1 and p2.
    }
}

Dopo l'esecuzione del codice nell'istruzione, tutte le variabili bloccate vengono sbloccate e sottoposte alla procedura di Garbage Collection. Di conseguenza, evitare di puntare a quelle variabili esterne all'istruzione fixed.

Nota:
I puntatori inizializzati nelle istruzioni fixed non possono essere modificati.

In modalità non protetta, è possibile allocare memoria nello stack, che non è necessario bloccare perché lo stack non viene sottoposto alla procedura di Garbage Collection. Per ulteriori informazioni, vedere stackalloc.

Esempio

class Point
{ 
    public int x, y; 
}

class FixedTest2 
{
    // Unsafe method: takes a pointer to an int.
    unsafe static void SquarePtrParam (int* p) 
    {
        *p *= *p;
    }

    unsafe static void Main() 
    {
        Point pt = new Point();
        pt.x = 5;
        pt.y = 6;
        // Pin pt in place:
        fixed (int* p = &pt.x) 
        {
            SquarePtrParam (p);
        }
        // pt now unpinned
        Console.WriteLine ("{0} {1}", pt.x, pt.y);
    }
}
/*
Output:
25 6
 */

Specifiche del linguaggio C#

Per ulteriori informazioni, vedere le sezioni riportate di seguito in Specifiche del linguaggio C#:

• 18.3 Variabili fisse e mobili

• 18.6 Istruzione fixed

Vedere anche

Concetti

Guida per programmatori C#

Riferimenti

Parole chiave di C#

unsafe (Riferimenti per C#)

Buffer a dimensione fissa (Guida per programmatori C#)

Altre risorse

Riferimenti per C#