C#构造函数里的base和this的区别

实例一:

  父类的构造函数总是在子类之前执行的。既先初始化静态构造函数，后初始化子类构造函数。

public class BaseCircle {
        public BaseCircle()
        {
            Console.WriteLine(" no arguments base constructor!!!");
        }
        public BaseCircle(double arg)
        {
            Console.WriteLine("double arg base constructor!!!");
        }
    }
 
    public class SubCircle : BaseCircle {
        public SubCircle():base()
        {
            Console.WriteLine("sub class no argument constructor,actually call base constructor !!!");
        }
 
        public SubCircle(double a):base(a)
        {
            Console.WriteLine("sub class with argument, actually call base double constructor!!!");
        }
 
        public SubCircle(int k):this(1,2)
        {
            Console.WriteLine("sub class with argument int k, actually call sub class constructor int i & j !!!");
        }
 
        public SubCircle(int i,int j)
        {
            Console.WriteLine("sub class with int i&j argument!!!!");
        }
    }
 
static void Main(string[] args)
        {
            SubCircle s1 = new SubCircle();
            SubCircle s2 = new SubCircle(1.1);
            SubCircle s3 = new SubCircle(1);
｝

输出结果：
no arguments base constructor!!!
sub class no argument constructor,actually call base constructor !!!
 
double arg base constructor!!!
sub class with argument, actually call base double constructor!!!
 
 no arguments base constructor!!!
sub class with int i&j argument!!!!
sub class with argument int k, actually call sub class constructor int i & j !!!

实例2：

class BaseClass
    {
        private int numA;
        public BaseClass()
        {
            Console.WriteLine("基类的无参数构造函数. value:{0}", numA);
        }
        public BaseClass(int i)
        {
            this.numA = i;
            Console.WriteLine("基类带一个参数的构造函数. value:{0}", numA);
        }
    }
    class ChildClassA : BaseClass
    {
        private int numB;
        public ChildClassA()
        {
            Console.WriteLine("子类无参数构造函数. value:{0}", numB);
        }
        public ChildClassA(int i)
        {
            this.numB = i;
            Console.WriteLine("子类带有一个参数的构造函数. value:{0}", numB);
        }
        public ChildClassA(int i, int j)
            : base(i)
        {
            this.numB = j;
            Console.WriteLine("子类带有两个参数的构造函数. value:{0}", numB);
        }
    }
    class ChildClassB : BaseClass
    {
        private int numB;
        public ChildClassB()
        {
            Console.WriteLine("子类无参数构造函数. value:{0}", numB);
        }
        public ChildClassB(int i)
        {
            this.numB = i;
            Console.WriteLine("子类带有一个参数的构造函数. value:{0}", numB);
        }
        public ChildClassB(int i, int j)
            : this(i)
        {
            this.numB = j;
            Console.WriteLine("子类带有两个参数的构造函数. value:{0}", numB);
        }
    }
    class Demo
    {
        static void Main(string[] args)
        {
            Console.WriteLine("使用base\n");
            ChildClassA a = new ChildClassA(2, 4);
            Console.WriteLine();
            Console.WriteLine("----------------------------------------\n");
            Console.WriteLine("使用this\n");
            ChildClassB b = new ChildClassB(2, 4);
            Console.ReadKey();
        }
    }

执行的结果如下：

--------------------------------结果----------------------------------
 
使用base
 
基类带一个参数的构造函数. value:2
子类带有两个参数的构造函数. value:4
 
----------------------------------------
 
使用this
 
基类的无参数构造函数. value:0
子类带有一个参数的构造函数. value:2
子类带有两个参数的构造函数. value:4
 
--------------------------------结果--------------------------------

this 只是调用本身，但是这样是需要调用一次基类没有参的构造函数，所以会多显示一条“基类的无参数构造函数. value:0”。

base 是调用基类的有参数构造函数。