C#构造函数、私有构造函数、静态构造函数与构造函数执行顺序 ...

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Node.js›Node.js教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

https://www.cnblogs.com/ArtofDesign/p/3603986.html

默认构造函数，如果没有为类指定任何构造函数，编译器会自动为类创建一个无参构造函数，用以初始化类的字段；如果为类编写了构造函数，那么编译器就不会再自动生成无参构造函数了。ps.C#不允许用户为结构定义无参构造函数。

静态构造函数，不能访问实例成员，只能用来初始化一些静态字段或者属性，仅在第一次调用类的任何成员时自动执行，不带访问修饰符，不带任何参数，每个类只能有一个静态构造函数，但可以同时还有一个无参实例构造函数，如下。

public class Demo
{
    static Demo() { }
    public Demo() { }
}

私有构造函数，将构造函数申明为私有的，则不能通过new运算符在外部代码中实例化（但可以编写一个静态方法或属性在其内部实例化一个对象，再将结果返回给外部代码）。私有构造函数的作用：

永远不会实例化，因为它仅用作某些静态成员的容器
希望类只能通过调用某个静态方法来实例化（即所谓的对象实例化的类工厂方法）

    public class Demo
    {
        private Demo() { }
        public static Demo NewDemo()
        {
            return new Demo();
        }
    }

构造函数执行顺序，通常情况下：构造函数先调用System.Object的构造函数，再按照继承的层次结构从上往下进行，直到最终要实例化的类为止，即最先调用的是基类的构造函数，但如果类有静态构造函数，且为首次调用该类，则先调用的是子类的静态构造函数，再是父类的静态构造函数，当然静态构造函数只会执行这一次，如下

//父类
public class SuperClass
{
    static SuperClass() 
    {
        Console.WriteLine("Super.Static");
    }
    public SuperClass() 
    {
        Console.WriteLine("Super.Instance");
    }
}

//子类
public class ChildClass : SuperClass
{
    static ChildClass() 
    {
        Console.WriteLine("Child.Static");
    }
    public ChildClass() 
    {
        Console.WriteLine("Child.Instance");
    }
}

//客户程序
class Program
{
    static void Main(string[] args)
    {
        ChildClass cc = new ChildClass();
        Console.ReadKey();
    }
}

输出结果为：

Child.Static

Super.Static

Super.Instance

Child.Instance

在不考了静态构造函数的情况下（因为静态构造仅执行一次，且定义静态构造函数的时候并不多），子类在调用父类的构造函数时，默认情况是调用父类的无参构造函数，如果父类只有带参构造函数，而没有无参构造函数，那么编译时会报错；不过我们可以通过base关键字来指定调用带参构造函数，如下

//父类
public class SuperClass
{
    public SuperClass(string param)
    {
        Console.WriteLine("Super:" + param);
    }
}

//子类
public class ChildClass : SuperClass
{
    public ChildClass(string param):base(param)
    {
        Console.WriteLine("Child:" + param);
    }
}

//客户程序
class Program
{
    static void Main(string[] args)
    {
        ChildClass cc = new ChildClass("param");
        Console.ReadKey();
    }
}

输出结果为

Super:param

Child:param

public class SuperStaticConstructor
    {
        public SuperStaticConstructor()
        {
            Console.WriteLine("parent constructor");
        }

        static SuperStaticConstructor()
        {
            Console.WriteLine("parent static constructor");
        }
    }
    public class StaticConstructor: SuperStaticConstructor
    {
        public StaticConstructor()
        {
            Console.WriteLine("child constructor");
        }

        static StaticConstructor()
        {
            Console.WriteLine("child static constructor");
        }
    }

    public class StaticConstructorTest
    {
        public static void Run()
        {
            string[] strArray = new string[4]{ "a","b", "a", "b" };
            Parallel.ForEach(strArray, (item) =>
            {
                Console.WriteLine(item);
                new StaticConstructor();
            });
        }
    }

　　StaticConstructorTest.Run();