Operator new in C# vs C++

Question

Coming from C++, I am confused as to the use of the new keyword in C#.

I understand that it doesn't work like C++'s new in the sense that you do not have to manually control the lifetime of the object, as C# has garbage collection.

However, when reading over other peoples C# code I notice statements like in code snippet 1. Wouldn't it be far easier to avoid the use of new altogether, like in code snippet 2?

Snippet 1

Foo fooInstance = new Foo();

Snippet 2

Foo fooInstance;

My question is, what are the differences between snippet 1 and snippet 2, and why should I prefer one over the other?

Answer 1

We must discriminate between three cases:

1. local variables
2. (non-static) fields inside structs
3. fields inside classes

---

For local variables, that is variables declared inside a method (or inside a constructor, or property/indexer/event accessor), the two are not equivalent:

class C
{
  void M()
  {
    Foo fooInstance = new Foo();
    // the variable is "definitely assigned" and can be read (copied, passed etc)
    // consider using the 'var' keyword above!
  }
}

class C
{
  void M()
  {
    Foo fooInstance;
    // the variable is not "definitely assigned", you cannot acquire its value
    // it needs to be assigned later (or can be used as 'out' parameter)
  }
}

---

For instance fields (non-static fields) inside a struct, only one of the "snippets" is allowed:

struct S
{
  Foo fooInstance = new Foo(); // compile-time error! cannot initialize here
}

struct S
{
  Foo fooInstance; // OK, access level is 'private' when nothing is specified
}

---

For fields inside a class (and static fields of a struct), the situation depends on whether Foo itself is a reference type (class) or a value type (struct or enum). The default value default(Foo) of a reference type is null, the reference that does not refer anything. The default value default(Foo) or a value type is the "instance" of the type where all fields have their default values. For value types (struct and enum), new Foo() (no arguments) and default(Foo) is the same thing. Therefore:

class C
{
  Foo fooInstance = new Foo(); // OK, private
}

class C
{
  Foo fooInstance; // OK, private
  // equivalent to 'Foo fooInstance = null;' if 'Foo' is a reference type (class, interface, delegate, array)
  // equivalent to 'Foo fooInstance = new Foo();' is 'Foo' is a value type (struct, enum)
}

---

It should be noted that if Foo is a reference type, the expression new Foo() is only allowed if the type actually has a constructor that takes 0 arguments, and if that constructor is accessible.

In (1) we disregarded the silly case where Foo is a struct with no instance fields.