Istruzione fixed (Riferimenti per C#)

L'istruzione fixed impedisce che il Garbage Collector esegua la rilocazione di una variabile mobile. L'istruzione fixed è consentita solo in un contesto di tipo unsafe. Fixed può essere utilizzato 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 that the following class exists.
    //class Point 
    //{ 
    //    public int x;
    //    public int y; 
    //}

    // Variable 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 that it is not relocated.

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

}

È possibile inizializzare un puntatore utilizzando una matrice, una stringa, un buffer a dimensione fissa o l'indirizzo di una variabile. Nell'esempio riportato di seguito viene illustrato l'utilizzo di indirizzi, matrici e stringhe variabili. Per ulteriori informazioni sui buffer di dimensioni fisse, vedere Buffer a dimensione fissa (Guida per programmatori C#).

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

    // The following two assignments are equivalent. Each assigns the address
    // of the first element in array arr to pointer p.

    // You can initialize a pointer by using an array.
    fixed (double* p = arr) { /*...*/ }

    // You can initialize a pointer by using the address of a variable. 
    fixed (double* p = &arr[0]) { /*...*/ }

    // The following assignment initializes p by using a string.
    fixed (char* p = str) { /*...*/ }

    // The following assignment is not valid, because str[0] is a char, 
    // which is a value, not a variable.
    //fixed (char* p = &str[0]) { /*...*/ } 


    // You can initialize a pointer by using the address of a variable, such
    // as point.x or arr[5].
    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 i puntatori di tipi diversi, annidare semplicemente le istruzioni fixed come illustrato nell'esempio seguente.

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.

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 la Specifiche del linguaggio C#. La specifica del linguaggio è la fonte ufficiale per la sintassi e l'utilizzo di C#.

Vedere anche

Riferimenti

Parole chiave di C#

unsafe (Riferimenti per C#)

Buffer a dimensione fissa (Guida per programmatori C#)

Concetti

Guida per programmatori C#

Altre risorse

Riferimenti per C#

Cronologia delle modifiche