c#静态构造函数 与 构造函数 你是否还记得？（转载）

构造函数这个概念，在我们刚开始学习编程语言的时候，就被老师一遍一遍的教着。亲，现在你还记得静态构造函数的适用场景吗？如果没有，那么我们一起来复习一下吧。
静态构造函数是在构造函数方法前面添加了static关键字之后形成的，并且没有修饰符(public,private),没有参数。

静态构造函数有哪些特点呢：

1. 静态构造函数没有修饰符修饰(public,private),因为静态构造函数不是我们程序员调用的，是由.net 框架在合适的时机调用的。
2. 静态构造函数没有参数，因为框架不可能知道我们需要在函数中添加什么参数，所以规定不能使用参数。
3. 静态构造函数前面必须是static 关键字。如果不加这个关键字，那就是普通的构造函数了。
4. 静态构造函数中不能实例化实例变量。（变量可以分为类级别和实例级别的变量，其中类级别的有static关键字修饰）。
5. 静态函数的调用时机，是在类被实例化或者静态成员被调用的时候进行调用，并且是由.net框架来调用静态构造函数来初始化静态成员变量。
6. 一个类中只能有一个静态构造函数。
7. 无参数的静态构造函数和无参数的构造函数是可以并存的。因为他们一个属于类级别，一个属于实例级别，并不冲突。
8. 静态构造函数只会被执行一次。并且是在特点5中的调用时机中进行调用。
9. 就像如果没有在类中写构造函数，那么框架会为我们生成一个构造函数，那么如果我们在类中定义了静态变量，但是又没有定义静态构造函数，那么框架也会帮助我们来生成一个静态构造函数来让框架自身来调用。

上面几个特点都是理论性的，我们来做一个找错题，帮助我们一起来学习静态构造函数。

public class C
    {
        public static string BB;
        public static C()
        {
            BB = "CC";
        }
        public static C(string mm)
        {
            BB = mm;
        }
        static C()
        {
            BB = "Right";
        }
        public C()
        {
            BB = "Wrong";
        }
        public C(string mm)
        {
            BB = mm;
        }
    }

VS编译提示的错误信息：

现在我们来做一个有意思的事情，验证静态构造函数的调用时机：

class Program
    {
        static void Main(string[] args)
        {

            Console.WriteLine(A.strText);
            Console.WriteLine(B.strText);
            Console.Read();
        }
    }
    public class A
    {
        public static string strText;
        public string Text;
        static A()
        {
            strText = "AAA";
        }
        public A()
        {
            Text = "AAAAAAAAAAAAAAAAAAAAAAAAAA";
        }
    }
    public class B:A
    {
        static B()
        {
            strText = "BBB";
        }
        public B()
        {
            Text = "BBBBBBBBBBBBBBBBB";
        }
    }

输出结果均为:AAA
我们来分析一下出现这个情况的原因所在，当显示A.strText的时候，因为strText是静态变量，所以框架会调用A的静态构造函数，此时strText的值为AAA.正确
当显示B.strText的时候，因为B继承自A，所以会首先调用A的静态构造函数，但是因为静态构造函数只会调用一次，所以不会调用A的静态构造函数，但是又因为strText属于类A，而不是B，所以B得静态构造函数不会执行，故输出的均为AAA。

但是如果我们把输出更改一下，输出结果就大不一样了。

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

            Console.WriteLine(A.strText);
            Console.WriteLine(B.strText);
          
            Console.Read();
        }
    }
    public class A
    {
        public static string strText;
        public string Text;
        static A()
        {
            strText = "AAA";
        }
        public A()
        {
            Text = "AAAAAAAAAAAAAAAAAAAAAAAAAA";
        }
    }
    public class B:A
    {
        static B()
        {
            strText = "BBB";
        }
        public B()
        {
            Text = "BBBBBBBBBBBBBBBBB";
        }
    }

请注意我在开始部分对类进行了实例化，那么此时的输出结果就是均为BBB。
为什么会有这样的情况出现呢，其实还是要从静态构造函数的调用时机入手。
首先我们实例化了B，此时会调用B的静态构造函数，但是因为strText是A的静态变量，所以首先会先调用A的静态构造函数将strText赋值为AAA，此时又会调用B的静态构造函数将strText赋值为BBB，所以此时strText的值应该为BBB，所以输出均为BBB。

我们再对代码进行更改，在类B中添加一个静态字符串变量strTextB，然后在B的静态构造函数中对strTextB赋值：

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(B.strText);
        Console.WriteLine(B.strTextB);
        Console.WriteLine(B.strText);
        Console.Read();
    }
}
public class A
{
    public static string strText;
    public string Text;
    static A()
    {
        strText = "AAA";
    }
    public A()
    {
        Text = "AAAAAAAAAAAAAAAAAAAAAAAAAA";
    }
}
public class B : A
{
    public static string strTextB;

    static B()
    {
        strText = "BBB";
        strTextB = "CCC";
    }
    public B()
    {
        Text = "BBBBBBBBBBBBBBBBB";
    }
}

这一次，输出结果如下：

AAA

CCC

BBB

• 首先在Main方法中，第一次使用B.strText访问了A的静态变量strText，所以此时A的静态构造函数被调用，因此B.strText输出AAA
• 接着在Main方法中，B.strTextB访问了B的静态变量strTextB，所以此时B的静态构造函数被调用，因此此时B.strTextB的值为CCC，且此时B.strText变为了BBB
• 最后在Main方法中，再次访问B.strText，此时A和B的静态构造函数都被调用过了，因此不会再被调用，但是B的静态构造函数在上一个步骤中已经将B.strText变为了BBB，所以此时B.strText输出BBB

接下来，我们再对代码做一个小的更改，这次我们在Main方法中先访问B.strTextB，再访问B.strText：

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(B.strTextB);
        Console.WriteLine(B.strText);
        Console.Read();
    }
}
public class A
{
    public static string strText;
    public string Text;
    static A()
    {
        strText = "AAA";
    }
    public A()
    {
        Text = "AAAAAAAAAAAAAAAAAAAAAAAAAA";
    }
}
public class B : A
{
    public static string strTextB;

    static B()
    {
        strText = "BBB";
        strTextB = "CCC";
    }
    public B()
    {
        Text = "BBBBBBBBBBBBBBBBB";
    }
}

输出结果如下：

CCC

BBB

那么这一次你是不是仿佛觉得A的静态构造函数没有被调用？实际上不是，我们来看看发生了什么：

首先在Main方法中，使用B.strTextB，会导致B的静态构造函数被调用，当B的静态构造函数执行strText = "BBB"对A的静态变量strText赋值时，由于strText是A的静态变量，且此时A的静态构造函数还没被调用过，所以此时会先调用A的静态构造函数，所以在这个时间点静态变量strText的值为AAA，但是当A的静态构造函数执行完毕后，紧接着B的静态构造函数立刻将静态变量strText又赋值为了BBB，所以在这个例子中，实际上是B的静态构造函数导致了A的静态构造函数被调用，静态变量strText首先被赋值为了AAA，但是紧接着B的静态构造函数又将静态变量strText赋值为了BBB

原文链接