Creating an Instance

Democlass D;

Creates a variable called "D" that can hold a reference to an object of type "Democlass", or a class derived from it. Assigns null to "D" - it refers to nothing.

Democlass D = new Democlass();

Does exactly the same as the previous example, except that an instance of DemoClass is created on the managed heap and assigned to "D".

The big difference is that in the first example, attempts to use D.Property or D.Method() will result in an exception being thrown, the second will work.

"Hi ,
Now,,Consider D has some reference ..Will it(variable D) be stored in the stack or heap?"

Depends on where it is declared.
If it is in a method: Stack
If it is in a Class: Heap (because the class is a reference type and goes on the heap, so it's content goes on the heap)
If it is in a Struct: stack (because it is a value type, and they go on the stack)

To add to Griff's Answer:

The variables can be stored in three places: stack, heap and the process's static memory area (recommended to keep to minimum). For the reference type, the variable (reference itself) can be stored in all three places, while the memory area pointed by reference is always heap (exclusion is C++/CLI where this limitation is removed due to its unique value semantic for reference types). Structure is a value type, as well as enumeration and primitive types, all other types are reference one.

For simplicity, I will not mention heap below, so just keep in mind the reference is pointing to heap.

Now, it depends on where the variable is declared: if the variable is static, it is stored in static memory area. If the variable is local, it always stored on stack. A field of reference type always goes to stack.

All this rules can be combined, as a structure can have reference-type fields and reference-type static fields, value-type fields and value-type static fields; and a class can have same combination of fields. Figure all possible structures yourself.

—SA