fixed-Anweisung (C#-Referenz)fixed Statement (C# Reference)

Die fixed-Anweisung verhindert, dass der Garbage Collector eine bewegliche Variable verschiebt.The fixed statement prevents the garbage collector from relocating a movable variable. Die fixed-Anweisung ist nur in einem unsicheren (unsafe) Kontext zulässig.The fixed statement is only permitted in an unsafe context. Fixed kann auch zum Erstellen eines Puffers fester Größe verwendet werden.Fixed can also be used to create fixed size buffers.

Die fixed-Anweisung setzt einen Zeiger auf eine verwaltete Variable und „fixiert“ diese Variable während der Ausführung der Anweisung.The fixed statement sets a pointer to a managed variable and "pins" that variable during the execution of the statement. Ohne fixed wären Zeiger auf bewegliche, verwaltete Variablen von geringem Nutzen, da die automatische Speicherbereinigung die Variablen auf unvorhersehbare Weise verschieben könnte.Without fixed, pointers to movable managed variables would be of little use since garbage collection could relocate the variables unpredictably. Mit dem C#-Compiler können Sie einer verwalteten Variablen nur in einer fixed-Anweisung einen Zeiger zuweisen.The C# compiler only lets you assign a pointer to a managed variable in a fixed statement.

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.You can initialize a pointer by using an array, a string, a fixed-size buffer, or the address of a variable. Im folgenden Beispiel wird die Verwendung von Adressen, Arrays und Zeichenfolgen von Variablen veranschaulicht.The following example illustrates the use of variable addresses, arrays, and strings. Weitere Informationen zu Puffern fester Größe finden Sie unter Puffer fester Größe.For more information about fixed-size buffers, see Fixed Size Buffers.

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.You can initialize multiple pointers, as long as they are all of the same type.

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

Um Zeiger verschiedener Typen zu initialisieren, schachteln Sie einfach fixed-Anweisungen, wie im folgenden Beispiel gezeigt.To initialize pointers of different types, simply nest fixed statements, as shown in the following example.

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.After the code in the statement is executed, any pinned variables are unpinned and subject to garbage collection. Aus diesem Grund sollten Sie nicht außerhalb der fixed-Anweisung auf diese Variablen verweisen.Therefore, do not point to those variables outside the fixed statement.

Hinweis

Zeiger, die in festen Anweisungen initialisiert werden, können nicht geändert werden.Pointers initialized in fixed statements cannot be modified.

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.In unsafe mode, you can allocate memory on the stack, where it is not subject to garbage collection and therefore does not need to be pinned. Weitere Informationen finden Sie unter stackalloc.For more information, see stackalloc.

BeispielExample

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#-ProgrammiersprachenspezifikationC# Language Specification

Weitere Informationen erhalten Sie unter C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.

Siehe auchSee Also

C#-ReferenzC# Reference
C#-ProgrammierhandbuchC# Programming Guide
C#-SchlüsselwörterC# Keywords
unsafeunsafe
Puffer fester GrößeFixed Size Buffers