Chapter 39: Constructors and Finalizers

Constructors are methods in a class that are invoked when an instance of that class is created. Their main responsibility is to leave the new object in a useful and consistent state.

Destructors/Finalizers are methods in a class that are invoked when an instance of that is destroyed. In C# they are rarely explicitely written/used.

Section 39.1: Static constructor

A static constructor is called the first time any member of a type is initialized, a static class member is called or a static method. The static constructor is thread safe. A static constructor is commonly used to:

Initialize static state, that is state which is shared across di erent instances of the same class. Create a singleton

Example:

class Animal

{

//* A static constructor is executed only once,

//when a class is first accessed.

//* A static constructor cannot have any access modifiers

//* A static constructor cannot have any parameters static Animal()

{

Console.WriteLine("Animal initialized");

}

//Instance constructor, this is executed every time the class is created public Animal()

{

Console.WriteLine("Animal created");

}

public static void Yawn()

{

Console.WriteLine("Yawn!");

}

}

var turtle = new Animal(); var giraffe = new Animal();

Output:

Animal initialized

Animal created

Animal created

View Demo

If the first call is to a static method, the static constructor is invoked without the instance constructor. This is OK, because the static method can't access instance state anyways.

Animal.Yawn();

This will output:

Animal initialized

Yawn!

See also Exceptions in static constructors and Generic Static Constructors .

Singleton example:

public class SessionManager

{

public static SessionManager Instance;

static SessionManager()

{

Instance = new SessionManager();

}

}

Section 39.2: Singleton constructor pattern

public class SingletonClass

{

public static SingletonClass Instance { get; } = new SingletonClass();

private SingletonClass()

{

// Put custom constructor code here

}

}

Because the constructor is private, no new instances of SingletonClass can be made by consuming code. The only way to access the single instance of SingletonClass is by using the static property SingletonClass.Instance.

The Instance property is assigned by a static constructor that the C# compiler generates. The .NET runtime guarantees that the static constructor is run at most once and is run before Instance is first read. Therefore, all synchronization and initialization concerns are carried out by the runtime.

Note, that if the static constructor fails the Singleton class becomes permanently unusable for the life of the AppDomain.

Also, the static constructor is not guaranteed to run at the time of the first access of Instance. Rather, it will run at some point before that. This makes the time at which initialization happens non-deterministic. In practical cases the JIT often calls the static constructor during compilation (not execution) of a method referencing Instance. This is a performance optimization.

See the Singleton Implementations page for other ways to implement the singleton pattern.

Section 39.3: Default Constructor

When a type is defined without a constructor:

using System.Runtime.CompilerServices;

// ...

RuntimeHelpers.RunClassConstructor(typeof(Foo).TypeHandle);

Remark: All static initialization (fields initializers for example) will run, not only the constructor itself.

Potential usages: Forcing initialization during the splash screen in an UI application or ensuring that a static constructor doesn't fail in an unit test.

Section 39.5: Calling a constructor from another constructor

public class Animal

{

public string Name { get; set; }

public Animal() : this("Dog")

{

}

public Animal(string name)

{

Name = name;

}

}

var dog = new Animal(); // dog.Name will be set to "Dog" by default.

var cat = new Animal("Cat"); // cat.Name is "Cat", the empty constructor is not called.

Section 39.6: Calling the base class constructor

A constructor of a base class is called before a constructor of a derived class is executed. For example, if Mammal extends Animal, then the code contained in the constructor of Animal is called first when creating an instance of a

Mammal.

If a derived class doesn't explicitly specify which constructor of the base class should be called, the compiler assumes the parameterless constructor.

public class Animal

{

public Animal() { Console.WriteLine("An unknown animal gets born."); } public Animal(string name) { Console.WriteLine(name + " gets born"); }

}

public class Mammal : Animal

{

public Mammal(string name)

{

Console.WriteLine(name + " is a mammal.");

}

}

In this case, instantiating a Mammal by calling new Mammal("George the Cat") will print

An unknown animal gets born.

George the Cat is a mammal.