C#

public class C : B{
    public void BaseM(){
        base.M();
    }
    public override void M(){
       //do stuff
    }
}

public interface ISillyInterface1{
    void M();
}
public interface ISillyInterface2{
    void M();
}
public class A : ISillyInterface1, ISillyInterface2{
    void ISillyInterface1.M(){
    }
    void ISillyInterface2.M(){
    }
}

using System;

namespace CallBaseClass
{
    class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            A b = new B();
            A c = new C();

            a.M();
            b.M();
            c.M();

            ((A)a).M();
            ((B)b).M();
            ((C)c).M();

            Console.ReadKey();
        }
    }

    class A
    {
        public virtual void M()
        {
            Console.WriteLine("A");
        }
    }

    class B : A
    {
        public new void M()
        {
            Console.WriteLine("B");
        }
    }

    class C : B
    {
        public new void M()
        {
            Console.WriteLine("C");
        }
    }
}

class A {
 public virtual void M(bool pDoBaseCall) {}
}

class B : A {
 public override void M(bool pDoBaseCall) {
  if (pDoBaseCall) {
   base.M(pDoBaseCall);
  } else {
   // B stuff
  }
 }
}

class C : A {
 public override void M(bool pDoBaseCall) {
  if (pDoBaseCall) {
   base.M(pDoBaseCall);
  } else {
   // C stuff
  }
 }
}

//...call like

C c = new C();
c.M(true);
// or
c.M(false);
// depending on what you want

public class MyClass
{
   private int myField;

   public MyClass() : this(123) {}

   public MyClass(int field)
   {
      myField = field;
      // Do other constructor stuff here
   }
}

public class MyClass
{    
    public const int DefaultMyField = 123;

    private int myField;

    public MyClass()
        : this(DefaultMyField)
    { }
    public MyClass(int myField)
    {
        this.myField = myField;
    }
}

public class X
{
    int y ;
    int z ;

    public X 
    (
         int y
    )
    {
        this.y = y  ;
        this.z = 42 ;

        return ;
    }
}

The default value initialization described in §17.4.3 occurs for all fields, including fields that have variable
initializers. Thus, when a class is initialized, all static fields in that class are first initialized to their default
values, and then the static field initializers are executed in textual order. Likewise, when an instance of a
class is created, all instance fields in that instance are first initialized to their default values, and then the
instance field initializers are executed in textual order. When there are field declarations in multiple partial
type declarations for the same type, the order of the parts is unspecified. However, within each part the field
initializers are executed in order.

The instance field variable initializers of a class correspond to a sequence of assignments that are executed
immediately upon entry to any one of the instance constructors (§17.10.2) of that class. The variable
initializers are executed in the textual order in which they appear in the class declaration. The class instance
creation and initialization process is described further in §17.10.

Form2 frm2 = new Form2();
int height = frm2.Height;
int width = frm2.Width;

InspectionImageDialog m_ImgDlg = new InspectionImageDialog();
InspectionResultDialog m_RltDlg = new InspectionResultDialog();
Intel_Amd_InfoDialog intelamdDialog = new Intel_Amd_InfoDialog();