fixed-Anweisung (C#-Referenz)

Aktualisiert: November 2007

Die fixed-Anweisung verhindert, dass der Garbage Collector eine bewegliche Variable verschiebt. Die fixed-Anweisung ist nur in einem unsafe-Kontext zulässig. Fixed kann auch zum Erstellen von Puffer fester Größe verwendet werden.

Die fixed-Anweisung legt einen Zeiger auf eine verwaltete Variable fest und "fixiert" diese Variable während der Ausführung der Anweisung. Zeiger auf bewegliche, verwaltete Variablen wären ohne fixed von geringem Nutzen, da Garbage Collection die Variablen auf unvorhersehbare Weise verschieben könnte. Der C#-Compiler erlaubt die Zuweisung von Zeigern auf verwaltete Variablen nur in einer fixed-Anweisung.

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;
    }        

}

Ein Zeiger kann mit einer Adresse eines Arrays oder einer Zeichenfolge initialisiert werden:

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.
        }
    }

}

Mehrere Zeiger können initialisiert werden, solange sie denselben Typ aufweisen:

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

Um Zeiger verschiedenen Typs zu initialisieren, schachteln Sie einfach fixed-Anweisungen:

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

Nach der Ausführung des Anweisungscodes können beliebige fixierte Variablen wieder gelöst und für Garbage Collection freigegeben werden. Zeigen Sie daher nicht außerhalb der fixed-Anweisung auf solche Variablen.

Hinweis:
Zeiger, die in fixed-Anweisungen initialisiert wurden, können nicht geändert werden.

Im nicht sicheren Modus kann Speicher auf dem Stapel reserviert werden. Dort unterliegt er nicht Garbage Collection und muss daher nicht fixiert werden. Weitere Informationen finden Sie unter stackalloc.

Beispiel

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

C#-Programmiersprachenspezifikation

Weitere Informationen finden Sie in den folgenden Abschnitten von C#-Programmiersprachenspezifikation:

• 18.3 Feste und bewegliche Variablen

• 18.6 Die fixed-Anweisung

Siehe auch

Konzepte

C#-Programmierhandbuch

Referenz

C#-Schlüsselwörter

unsafe (C#-Referenz)

Puffer fester Größe (C#-Programmierhandbuch)

Weitere Ressourcen

C#-Referenz