How to tell whether a variable has been initialized in C#?

Question

I know this is a dumb question and I guess it must have been asked before. However I am unable to find an answer to my question.

Here is some sample code (which of course does not compile) to outline my problem:

class test
{
     int[] val1;
     string val2;

     static bool somefunction(test x, test y)
     {
         dosomestuff()

         test result;

         while(result is nothing)
         {
              if(somecondition){result=new test(something);}
         }
     }
}

The problem which I have is in the following line:

while(result is nothing)

This is the syntax from VB, which of course is not what the C# compiler accepts. Could somebody tell me how to resolve the problem?

Answer 1

• TL;DR:

  if (Object.Equals(myVariable, default(MyVariableType)))

  • Replace myVariable and MyVariableType.
  
  There are other solutions.

---

if (myVariable == null) will not work^[1] with value types.
(See further below for short intros to  reference types vs. value types   and structs.)

The value types mainly are structs (e.g. DateTime), including^[2] the simple types like int, and enumerations. Value types don't support a null value (intrinsically).

The exception and the fix to this are nullable types: Essentially these add null to the possible values of a struct type. They are structurally the same as the Maybe<T> you might know from other languages^[3]. You create them with ValueType? (e.g. int?) which is syntactic sugar for Nullable<ValueType>.

Alternatively, instead of using a nullable type, you could compare your variable to its type's default value:

if (Object.Equals(myVariable, default(MyVariableType)))

(This will work both for reference types (objects) and value types.)
Note that you have to replace MyVariableType manually – unfortunately you can not do

if (Object.Equals(myVariable, default(myVariable.GetType())))

because default() only accepts a type name directly. (I suppose it evaluates at compile-time.)

structs in a nutshell

Put simply, structs are cut-down classes. Imagine classes that don’t support inheritance or finalizers, and you have the cut-down version: the struct. Structs are defined in the same way as classes (except with the struct keyword), and apart from the limitations just described, structs can have the same rich members, including fields, methods, properties and operators.
_{[Cited from: http://www.albahari.com/valuevsreftypes.aspx ]}

Classes are reference types: A class variable (or more specifically, its memory area) only contains a pointer to an other memory area, where the actual object instance data is stored.

Value type variables directly contain the data. This may yield a speed benefit due to cache locality and saving the lookup. But it may also be detrimental to performance in the case of more complex structs.

---

Footnotes:

[1] It does not even throw an error. myVariable == null will always just yield false, because your myVariable will be initialized with the non-null default value (zero (equivalent) or a struct of zeros and nulls). This default value is available with default(Type).

[2] Technically the simple types (all built-in types except string and object) are structs. Side note: The built-in types are aliases for types from the System namespace.

[3] E.g. in Haskell. In C# Maybe<T> is not built-in, but can be implemented. It provides Nothing as a more explicit/self-documenting version of null both for classes and structs.

[4] There is no ^[4]. No really, you can go and check.