.NET Answers

Since I’ve already mentioned my bias against using unsafe mode in this post:

Advanced CSharp – unsafe mode

I’ll skip my normal rant about that.  Just suffice it to say they don’t call it “unsafe” for nothing.

So assuming you have some valid use for using unsafe mode, you’ll also need to make sure your memory isn’t moving around on you while you are accessing the pointers you’ve created in your unsafe block.  For that, you’ll need the fixed keyword.

While the unsafe mode gives you the ability to use pointers in the first place, fixed makes sure the pointers aren’t moving around while you are using them.  We need both so that we only fix the memory in its location while we are using it while still being able to write normal code within our unsafe block.

To create a pointer to a variable, you use the asterisk (*).  To retrieve the address of a variable (so you can assign it to the variable) you use the ampersand (&).  Just like we did in C++ for those of you who are familiar with that language.

So to create a pointer to an integer, your code might look something like this:

public unsafe void Foo()
{
    int i = 20;
    int* pi = &i;
}

At this point, pi points to i, which holds the value of 20.

But if we want to use pi to retrieve the value of 20, we want to make sure that the memory location of i doesn’t move while we are retrieving it.

Arguably, this is much more important when we are trying to access arrays in a loop.  But to keep the illustration simple we’ll continue with retrieving our single integer value.

public unsafe void Foo()
{
    int i = 20;
    int copyOfI;
    fixed (int* pi = &i)
    {
        copyOfI = *pi;
    }
}

Now we can be sure that every time we access pi, it will still be pointing to the variable i.