NGWS SDK Documentation  

This is preliminary documentation and subject to change.
To comment on this topic, please send us email at ngwssdk@microsoft.com. Thanks!

10.10.3 Constructor execution

It is useful to think of instance variable initializers and constructor initializers as statements that are automatically inserted before the first statement in the block of a constructor. The example

class A
{
   int x = 1, y = -1, count;
   public A() {
      count = 0;
   }
   public A(int n) {
      count = n;
   }
}
class B: A
{
   double sqrt2 = Math.Sqrt(2.0);
   ArrayList items = new ArrayList(100);
   int max;
   public B(): this(100) {
      items.Add("default");
   }
   public B(int n): base(n – 1) {
      max = n;
   }
}

contains several variable initializers and also contains constructor initializers of both forms (base and this). The example corresponds to the code shown below, where each comment indicates an automatically inserted statement (the syntax used for the automatically inserted constructor invocations isn’t valid, but merely serves to illustrate the mechanism).

class A
{
   int x, y, count;
   public A() {
      x = 1;                        // Variable initializer
      y = -1;                        // Variable initializer
      object();                     // Invoke object() constructor
      count = 0;
   }
   public A(int n) {
      x = 1;                        // Variable initializer
      y = -1;                        // Variable initializer
      object();                     // Invoke object() constructor
      count = n;
   }
}
class B: A
{
   double sqrt2;
   ArrayList items;
   int max;
   public B(): this(100) {
      B(100);                        // Invoke B(int) constructor
      items.Add("default");
   }
   public B(int n): base(n – 1) {
      sqrt2 = Math.Sqrt(2.0);         // Variable initializer
      items = new ArrayList(100);   // Variable initializer
      A(n – 1);                     // Invoke A(int) constructor
      max = n;
   }
}

Note that variable initializers are transformed into assignment statements, and that these assignment statements are executed before the invocation of the base class constructor. This ordering ensures that all instance fields are initialized by their variable initializers before any statements that have access to the instance are executed. For example:

class A
{
   public A() {
      PrintFields();
   }
   public virtual void PrintFields() {}
}
class B: A
{
   int x = 1;
   int y;
   public B() {
      y = -1;
   }
   public override void PrintFields() {
      Console.WriteLine("x = {0}, y = {1}", x, y);
   }
}

When new B() is used to create an instance of B, the following output is produced:

x = 1, y = 0

The value of x is 1 because the variable initializer is executed before the base class constructor is invoked. However, the value of y is 0 (the default value of an int) because the assignment to y is not executed until after the base class constructor returns.