C#构造函数

一、简介

构造函数，基本用法是在类对象声明的时候完成初始化工作。

二、实例构造函数

1、构造函数的名字与类名相同。

2、使用 new 表达式创建类的对象或者结构（例如int）时，会调用其构造函数。并且通常初始化新对象的数据成员。

3、除非类是静态的，否则会为没有构造函数的类，自动生成一个默认构造函数，并使用默认值来初始化对象字段。

4、构造函数可以有参数，可以以多态的形式存在多个构造函数。

代码：

 class CoOrds
    {
        public int x, y;
        // 实例构造函数（默认构造函数）
        public CoOrds()
        {
            x = 0;
            y = 0;
        }
        // 具有两个参数的构造函数
        public CoOrds(int x, int y)
        {
            this.x = x;
            this.y = y;
        }

        // 重写toString方法
        public override string ToString()
        {
            return (String.Format("({0},{1})", x, y));
        }
        static void Main(string[] args)
        {
            CoOrds p1 = new CoOrds();//调用默认的无参构造函数
            CoOrds p2 = new CoOrds(5, 3);//调用两个参数构造函数

            // 使用重写ToString方法显示结果
            Console.WriteLine("CoOrds #1 at {0}", p1);
            Console.WriteLine("CoOrds #2 at {0}", p2);
            Console.ReadKey();
        }
    }

    /* Output:
     CoOrds #1 at (0,0)
     CoOrds #2 at (5,3)        
    */

分析：

1.其中CoOrds()是构造函数，诸如此类不带参数的构造函数称为“默认构造函数”。

2.CoOrds(int x, int y)同样也是构造函数，构造函数可以有参数，允许多态。

三、静态构造函数

1.静态构造函数不使用访问修饰符或不具有参数。
2.在创建第一个实例或引用任何静态成员之前，将自动调用静态构造函数以初始化类。
3.不能直接调用静态构造函数。
4.用户无法控制在程序中执行静态构造函数的时间。
5.静态构造函数的一种典型用法是在类使用日志文件且将构造函数用于将条目写入到此文件中时使用。
6.静态构造函数对于创建非托管代码的包装类也非常有用，这种情况下构造函数可调用 LoadLibrary 方法。
7.如果静态构造函数引发异常，运行时将不会再次调用该函数，并且类型在程序运行所在的应用程序域的生存期内将保持未初始化。

代码1：

    class TestClass
    {
        public static int x = 0;
        //构造函数
        TestClass()
        {
            x = 1;
        }
        //静态构造函数
        static TestClass()
        {    //第二步，执行x = 2
            x = 2;
        }    
        //第一步，程序入口Main最先执行。然后执行public static int x = 0 接着执行静态构造函数。
        public static void Main(string[] args)
        {
            Console.WriteLine("x:{0}", x); //打印，x = 2
            TestClass Test = new TestClass();//第三步执行构造函数，此时x = 1
            Console.WriteLine("x:{0}", x); //打印 x = 1
            Console.Read();
        }
    }

分析1：

1.Main是程序入口，当执行Main的时候，最先执行public static int x = 0
2.接着执行静态构造函数，此时 x = 2
3.然后执行Main函数里面的内容，打印 x，此时 x = 2
4.初始化TestClass，然后会执行构造函数，此时 x = 1
5.打印 x = 1

代码2：

    public class A
    {
        public static readonly int x;
        static A()
        {
            //第二步，调用B.y，此处B.y = 0，因为int类型在初始化阶段，会给赋默认值，默认值为0。最后x = 0 + 1（返回给第一步）
            x = B.y + 1;
        }
    }
    public class B
    {
        //第一步，调用A.x，然后执行类A的静态构造函数，等待返回（第二步返回的A.x = 1，所以y = 1 + 1）
        public static int y = A.x + 1;
        public static void Main(string[] args)
        {
            //第三步，A.x = 1，y = 2。
            Console.WriteLine("x:{0},y:{1}。", A.x, y);
            Console.ReadLine();
        }
    }

分析2：

1.首先，每一个项目有且只能有一个静态类的Main函数作为入口函数。而入口函数是最先执行的。
2.由于Main函数在B类里面，首先会初始化B类。而类的初始化顺序是：类里的静态变量，然后执行静态构造函数。
3.运行起先执行 public static int y = A.x + 1 这个，执行的时候，会先把 y 初始化为0，然后计算 y 的值。
4.计算 y 的值的时候，调用了 A 的静态变量 x 。所以会先初始化A。
5.初始化A时首先去执行 public static readonly int x ，先把 x 初始化为0。
6.然后执行A的静态构造函数 x = B.y + 1 此时 y 已经初始化为0了。
7.计算得到 x = 1。然后回到 public static int y = A.x + 1 得到 y = 2。
8.然后再执行Main函数的内容。得出结果x=1，y=2

四、私有构造函数

私有构造函数是一种特殊的实例构造函数。 它通常用于只包含静态成员的类中。 如果类具有一个或多个私有构造函数而没有公共构造函数，则其他类（除嵌套类外）无法创建该类的实例。

代码：

  public class PrivateConstructor
    {
        private PrivateConstructor()
        {
            //PrivateTest a = new PrivateTest();
            //注释打开会报错，错误信息：不可访问，因为它受保护级别限制。因为私有构造函数无法在类的外面实例化。
        }
        public class PrivateTest
        {
            int i;
            private PrivateTest()
            {
                i = 3;
            }
            static void Main(string[] args)
            {
                PrivateConstructor t = new PrivateConstructor(); //嵌套类允许实例化。
                PrivateTest p = new PrivateTest(); //类的内部允许实例化。
                Console.WriteLine("i:{0}", p.i); //结果：i：3
                Console.Read();
            }
        }
    }

分析：

声明空构造函数可阻止自动生成默认构造函数。 请注意，如果不对构造函数使用访问修饰符，则在默认情况下它仍为私有构造函数。 但是，通常会显式地使用 private 修饰符来清楚地表明该类不能被实例化。