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, voir 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
Mémoires tampons de taille fixe (Guide de programmation C#)