fixed-Anweisung (C#-Referenz)

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

Die fixed-Anweisung setzt einen Zeiger auf eine verwaltete Variable und „fixiert“ diese Variable während der Ausführung der Anweisung. Ohne fixed wären Zeiger auf bewegliche, verwaltete Variablen von geringem Nutzen, da die automatische Speicherbereinigung die Variablen auf unvorhersehbare Weise verschieben könnte. Mit dem C#-Compiler können Sie einer verwalteten Variablen nur in einer fixed-Anweisung einen Zeiger zuweisen.

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

Sie können einen Zeiger mit einem Array, einer Zeichenfolge, einem Puffer fester Größe oder der Adresse einer Variablen initialisieren. Im folgenden Beispiel wird die Verwendung von Adressen, Arrays und Zeichenfolgen von Variablen veranschaulicht. Weitere Informationen zu Puffern fester Größe finden Sie unter Puffer fester Größe.

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

Sie können mehrere Zeiger initialisieren, solange sie alle dem gleichen Typ angehören.

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

Um Zeiger verschiedener Typen zu initialisieren, schachteln Sie einfach fixed-Anweisungen, wie im folgenden Beispiel gezeigt.

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

Nachdem der Code in der Anweisung ausgeführt wird, können beliebige fixierte Variablen gelöst und an die automatische Speicherbereinigung übergeben werden. Aus diesem Grund sollten Sie nicht außerhalb der fixed-Anweisung auf diese Variablen verweisen.

Hinweis

Zeiger, die in festen Anweisungen initialisiert werden, können nicht geändert werden.

Im nicht sicheren Modus können Sie dem Stapel Arbeitsspeicher zuweisen, auf dem der Speicher nicht automatisch bereinigt wird und daher nicht fixiert werden muss. 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

For more information, see the C# Language Specification. The language specification is the definitive source for C# syntax and usage.

Siehe auch

C#-Referenz
C#-Programmierhandbuch
C#-Schlüsselwörter
unsafe
Puffer fester Größe