Question

I am a bit confused on when fixed block is required. I have example which gives me a contradicting scenario below:

enum RoomType { Economy, Buisness, Executive, Deluxe };

struct HotelRoom
{
    public int Number;
    public bool Taken;
    public RoomType Category;

    public void Print()
    {
        String status = Taken ? "Occupied" : "available";
        Console.WriteLine("Room {0} is of {1} class and is currently {2}", Number, Category, status);
    }
}

I have made a function which will take a pointer to a HotelRoom

private unsafe static void Reserve(HotelRoom* room)
{
    if (room->Taken)
        Console.WriteLine("Cannot reserve room {0}", room->Number);
    else
        room->Taken = true;
}

In the main method I have the following:

unsafe static void Main(string[] args)
{
    HotelRoom[] myfloor = new HotelRoom[4];
    for (int i = 0; i < myfloor.Length; i++)
    {
        myfloor[i].Number = 501 + i;
        myfloor[i].Taken = false;
        myfloor[i].Category = (RoomType)i;
    }
    HotelRoom Room =  myfloor[1];
    Reserve(&Room);   //I am able to do this without fixed block.
    //Reserve(&myfloor[1]);  //Not able to do this so have to use fixed block below. 

    fixed (HotelRoom* pRoom = &myfloor[1])
    {
        Reserve(pRoom);
    }

    myfloor[1].Print();
    Room.Print();
}

My confusion is I am able to do Reserve(&Room) but not Reserve(&myfloor[1]). I think they’re doing the same thing – passing memeory address of a HotelRoom struct to the Reserve function. Why do I need fixed to do this?

Answer 1

Room is a local variable which is stored on stack, while myfloor is stored in heap. Garbage collector can move objects in the heap to compact it (adresses will change), so you need to “pin” them. That’s why you need fixed statement.

Update:

Also, there is a way to allocate memory on stack insted of heap:

HotelRoom* fib = stackalloc HotelRoom[4];

In this case you won’t need fixed statement.

Small disclamer: being able to do this doesn’t mean you should of course. As others already mentioned, it is very non-.NET way of writing code, so I just consider this question is theoretical.