C#-1

1.静态构造函数与Public构造函数：第一次创建类的实例时先调用静态构造函数，然后调用public构造函数。以后再创建该类的实例时就不再调用静态构造函数，只调用Public构造函数。（如果构造函数是私有的，说明这个类只想作为静态变量的一个容器，并不想有任何实例）

所有的类都至少包含一个构造函数。这些构造函数中可能有一个默认的构造函数，默认的构造函数没有参数，与类同名。其它带参数的构造函数称为非默认的构造函数。

在类的外部不能用私有的构造函数实例化对象，通过把默认的构造函数设置为私有，就可以强制类的用户使用非默认的构造函数。

一些类没有公共的构造函数，外部代码就不能实例化它。

静态成员，也称为共享成员，可以在类的实例之间共享。静态成员通过类直接引用。

一个类只能有一个静态的构造函数，该构造函数不能有访问修饰符，也不能带任何参数。静态构造函数不能直接调用，只能在下述情况下执行：

（1）创建包含静态构造函数的类的实例时

（2）访问包含静态构造函数的类的静态成员时

非静态构造函数也称实例构造函数。

静态类只包含静态成员，且不能用于实例化对象（如Console）。

内容出处：https://www.cnblogs.com/TJessica/p/6366066.html

下面为这个规则对应的实验：

using System;

using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace ConsoleApplication1
{
    class Class1
    {
        public static int con = 0;
        static Class1()
        {
            con++;
            Console.WriteLine("static "+con);
        }
        public Class1()
        { con++;
        Console.WriteLine("non-static-"+con);
        }

    }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Class1 o1 = new Class1();
            Class1 o2 = new Class1();
           // Console.WriteLine(Class1.con);
        }
    }

}

输出结果：static 1

non-static-2;

non-static-3;

2.多级继承时构造函数的执行顺序：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace ConsoleApplication1
{
    class Class1
    {
        public static int con1 = 0;
        static Class1()
        {
            con1++;
            Console.WriteLine("static con1="+con1);
        }
        public Class1()
        { con1++;
        Console.WriteLine("non-static con1="+con1);
        }
    }
    class Class2 : Class1
    { 
        public static int con2=0;
        static Class2()
        {
            con2++;con1++;
            Console.WriteLine("static ,con1="+con1+" con2="+con2);
        }
        public Class2()
        {
            con2++;con1++;
            Console.WriteLine("non-static ,con1=" + con1 + " con2=" + con2);
        }
    }
        class Class3 : Class2
    { 
        public static int con3=0;
        static Class3()
        {
            con2++;con1++;con3++;
            Console.WriteLine("static ,con1="+con1+" con2="+con2+" con3="+con3);
        }
        public Class3()
        {
            con2++;con1++;con3++;
            Console.WriteLine("non-static ,con1=" + con1 + " con2=" + con2 + " con3=" + con3);
        }
    }

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Class3 o1 = new Class3();
        }
    }

}

运行结果：

static con1=1

static ,con1=2 con2=1

static ,con1=3 con2=2 con3=1

non static con1=4;

non static con1=5,con2=3

non static con1=6 con2=4 con3=2

从结果可以看出先调用静态函数，从最基层的父类开始调用；静态函数都调完之后调共有构造函数，该类函数也是从基础父类开始调用。

关于这个的一个帖子：

我们使用VS的单步调试，来看父类和子类显式构造函数的执行顺序，如下图（动态图片，可以看到过程）：

很容易的可以发现，当创建子类对象的时候
①先调用了子类的构造函数
②调用了父类的构造函数
③执行了父类的构造函数

④执行了子类的构造函数

http://bbs.51cto.com/thread-1094007-1-1.html