fixed, instruction (référence C#)

L'instruction fixed empêche le Garbage Collector de déplacer une variable mobile. L'instruction fixed est autorisée uniquement dans un contexte unsafe. Fixed peut également être utilisé pour créer des mémoires tampons de taille fixe.

L'instruction fixed place un pointeur vers une variable managée et met cette variable en attente pendant l'exécution de l'instruction. Sans fixed, les pointeurs sur des variables managées seraient de peu d'utilité puisque le recyclage pourrait déplacer les variables de manière imprévisible. Le compilateur C# vous permet seulement d'affecter un pointeur à une variable managée dans une instruction 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;
    }        

}

Vous pouvez initialiser un pointeur à l'aide d'un tableau, d'une chaîne, d'une mémoire tampon de taille fixe, ou de l'adresse d'une variable. L'exemple suivant illustre l'utilisation d'adresses, de tableaux et de chaînes variables. Pour plus d'informations sur les mémoires tampon de taille fixe, consultez Mémoires tampons de taille fixe (Guide de programmation 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.
        }
    }
}

Vous pouvez initialiser plusieurs pointeurs, à condition qu'ils soient du même type.

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

Pour initialiser des pointeurs de types différents, imbriquez simplement les instructions fixed, comme illustré dans l'exemple suivant.

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

Après l'exécution du code contenu dans l'instruction, toutes les variables épinglées sont mises hors attente et soumises au recyclage. Aussi, ne pointez pas sur ces variables hors de l'instruction fixed.

Notes

Les pointeurs initialisés dans des instructions fixed ne peuvent être modifiés.

En mode unsafe, vous pouvez allouer de la mémoire à la pile dans laquelle elle n'est pas soumise au recyclage, et la mise en attente n'est donc pas nécessaire. Pour plus d'informations, consultez stackalloc.

Exemple

    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
     */

Spécification du langage C#

Pour plus d'informations, consultez la Spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Voir aussi

Référence

Mots clés C#

unsafe (référence C#)

Mémoires tampons de taille fixe (Guide de programmation C#)

Concepts

Guide de programmation C#

Autres ressources

Référence C#

Historique des modifications

Date	Historique	Motif
Avril 2011	A clarifié quels types peuvent être utilisés pour initialiser un pointeur.	Commentaires client.