Fixed statement

Motivation

GC may move a managed object around during runtime, so pointing to its address is not reliable since the address possibly changes all the time. So fixed is to tell the GC not moving the object around.

Person person = new();
unsafe
{
    // get address of a field and assign it to a new pointer
    fixed (int* ptr = &person.Age) 
    {
        // dereferencing, in which returns the variable and assign new value
        *ptr = 123; 
    }
    Console.WriteLine(person.Age);
}

class Person { public int Age; }

Managed and Unmanaged

• All enums are unmanaged
• All pointers are unmanaged
• All primitive types are unmanaged.
• User defined struct containing no managed field are unmanaged

When to use fixed?

class K { public int k; }
struct C
{
    public int instanceMember;
    public readonly static int shared;
    public const int con = 0;
    unsafe void M(int j, K k)
    {
        fixed (int* p = &j) { } // CS0213
        fixed (int* p = &k.k) { }
        int local = 0;
        fixed (int* p = &local) { } // CS0213
        int[] localArray = [];
        fixed (int* p = localArray) fixed (int* pp = p) { } // CS8385
        string localString = "abc";
        fixed (char* p = localString) fixed (char* pp = p) { } // CS8385
        K kk = new();
        fixed (int* p = &kk.k) { }
        fixed (int* p = &this.instanceMember) { }
        fixed (int* p = &C.shared) { }
        fixed (int* p = &C.con) { } // CS0211
    }
}

1. j lives inside the method only, and it's unmanaged so compiler yells.
2. k as a reference type and managed object, can be fixed.
3. local unmanaged can't be fixed
4. local array is managed but p is already fixed in previous statement.
5. same as 5.
6. local managed can be fixed
8. static fields are kept alive until the program ends then GC collects, so it's managed.
9. constants are simply values, not variable or field, there's no address for them.