Use of colon in C# constructor header

Question

Below is the constructor of a struct named Complex with two member variables, Real and Imaginary:

public Complex(double real, double imaginary) : this()
{
 Real = real;
 Imaginary = imaginary;
}

What is the use of the part after the colon in the function header?

Answer 1

You can always make a call to one constructor from within another. Say, for example:

public class mySampleClass
{
    public mySampleClass(): this(10)
    {
        // This is the no parameter constructor method.
        // First Constructor
    }

    public mySampleClass(int Age) 
    {
        // This is the constructor with one parameter.
        // Second Constructor
    }
}

this refers to same class, so when we say this(10), we actually mean execute the public mySampleClass(int Age) method. The above way of calling the method is called initializer. We can have at the most one initializer in this way in the method.

In your case it going to call default constructor without any parameter

Answer 2

It's called constructor chaining - where it's in fact calling another constructor (which takes no params in this case), and then comes back and does any additional work in this constructor (in this case setting the values of Real and Imaginary).

Answer 3

This is a constructor-initializer which invokes another instance constructor immediately before the constructor-body. There are two forms of constructor initializers: this and base.

base constructor initializer causes an instance constructor from the direct base class to be invoked.

this constructor initializer causes an instance constructor from the class itself to be invoked. When constructor initializer does not have parameters, then parameterless constructor is invoked.

class Complex
{
   public Complex() // this constructor will be invoked
   {    
   }

   public Complex(double real, double imaginary) : this()
   {
      Real = real;
      Imaginary = imaginary;
   }
}

BTW usually constructors chaining is done from constructors with less parameters count to constructors with more parameters (via providing default values):

class Complex
{
   public Complex() : this(0, 0)
   {    
   }

   public Complex(double real, double imaginary)
   {
      Real = real;
      Imaginary = imaginary;
   }
}

Answer 4

The : this() instructs the compiler to call the class's default constructor before executing the code found in this constructor. If the default constructor is empty, it has no actual effect.

Answer 5

It is called constructor chaining. Using it in a constructor to call another constructor. You can also do it for class inheritance, for example:

public class MyException : Exception
{
    public MyException(string message) : base(message){}
}

Answer 6

Its constructor chaining which calls default or parameterless constructor of the same class.

Answer 7

The call to the default constructor is useful (and required) when defining a struct that uses the C# shorthand notation for properties. For example:

public struct Foo
{
    public int X{get;set;}

    public Foo(int x)
    {
        X = x;
    }
}

The compiler will raise an error here because the 'this' object cannot be used within the constructor to assign X until all of the structs fields are assigned. Behind the scenes, a field is automatically created as a backing store for the property X, and calling the default constructor for the struct initializes this field (to the default value of 0 in this case).

See this question for further details: Automatically implemented property in struct can not be assigned