I sent out a tweet asking folks if they knew what the ?? operator in C# does. Quite a few people did, which was nice. For those of you that haven’t heard of it, here is my explanation.
If you are a C# programmer you will know about references. The way that C# works, a variable can be managed by value or reference. A variable of value type is stored in a location in memory. For example:
This creates an integer variable called i. When the program runs the system will decide where in memory the variable should live. You can think of computer memory as a whole bunch of numbered locations. Because that is what it is. Perhaps the variable i could live at memory location 5,000. Then when we write the code:
The effect of this is to put the value 99 in memory location number 5,000
So, if I write code like:
This would copy the value held in memory location 5,000 into the location where the integer variable j is stored.
This is how value types work. Whenever we do an assignment of a variable managed by value what happens is that the value is copied from one memory location to another.
So, what about values managed by reference? Well, in these there is a level of indirection between the variable and the actual data. Suppose we have a class called Account, which is managed by reference.
Account a = new Account();
This statement makes a new account variable and then sets the variable a to refer to it. The variable a will hold a reference to the new Account. Perhaps the new Account will be located at memory location 10,000 which means that the variable a (which might be stored at location 6,000) will hold the number 10,000 – because that is where the Account instance is stored. The Account class might have a Name property, so I can write code like:
When the program runs it will go to location 6,000 (where a is stored) and read the number out of there to find out where the Account is. In this case the variable a holds the number 10,000 and so the program will go to the Account there and set the name.
So if write code such as:
This creates a new Account reference called b which refers to the same Account instance as a, in other words it will refer to location 10,000.
So, in the case of the value the information is just there in memory, but for a reference we have to go where the reference refers. With references you can also set them to null:
This has the effect of putting a “magic value” in the variable a that indicates it really points nowhere. It is a way of saying “this reference does not point to any object”.
The null reference is often used in programs to indicate that the thing you asked for could not be found, or hasn’t been made yet, or doesn’t matter.
This “nullability” is so useful that people wanted to be able to make values “null” as well. So they invented one.
The addition of the question mark makes an integer variable (ageValue) that can be made null. For example, the bank might store the age of a customer when it is important (when the age is less than 20 say) but once a person reaches a certain age, from then on the age is completely irrelevant to the system. They can mark the ageValue as null to indicate this.
Programs can also test for null
if (customerAge != null)
{
// Stuff you do if the age matters
}
In XNA you often find nullable value parameters being sent to method, so that the method can know to ignore them.
So, I’ve been writing for what seems like ages, and I’ve still not explained what ?? does.
Well, ?? provides a convenient way that I can map the null value of a nullable variable onto a specific value
int actualAge = customerAge ?? -1;
It saves us having to write code that tests for null and sets a value appropriately. The above statement sets the value of actualAge to the value in customerAge unless the value in customerAge is null, in which case it sets it to –1.
if (customerAge == null)
actualAge = -1;
else
actualAge = customerAge;
In other words ?? is a short form of the above test.
