我可以在创建实例之前确保静态构造函数已经完成吗？

Question

我的类有一个在构造函数中使用的静态字段初始化器：

class Foo {
  private static List<string> list = new List<string>()
  private static object listLock = new Object();

  public Foo(string s) {
    lock(listLock)
      list.Add(s);
  }
}

我的问题是，它偶尔会发生，在静态初始化程序完成之前在构造函数中访问列表，导致访问list 时出现NullReferenceException。根据this question，只保证静态初始化在实例创建之前启动，而不是完成。

是否有某种方法可以确保仅在静态构造函数完成后才调用构造函数（除了像while(list == null){} 这样的丑陋黑客）？

Answer 1

Here's a good link on the nuances of before-field-init，但确实：添加显式静态构造函数应该强制运行时在此处处理。请注意，while (list == null) {} 将不起作用，因为它也会迫使运行时使用 - 基本上，您应该永远无法观察到运行时告诉您的谎言。

在所示示例中，没关系。你永远不会看到null 对应于listLock 或list。如果你真的要求它们在构造函数之前运行：

private static List<string> list;
private static object listLock;
static Foo() {
    list = new List<string>();
    listLock = new object();
}

但请注意，这并不是真正必要的，并且可能对您的代码产生负面影响，尤其是 .NET Core 3 中的新 JIT 可以用额外的巫术来处理 static readonly 字段如果他们被整齐地初始化（我知道如果它们是没有显式静态构造函数的内联字段初始化器，它可以做到这一点；我不知道它是否可以做到这一点如果它们是由显式静态构造函数分配的）。

Answer 2

我无法重现该问题。下面的程序并行创建了 5 个Foo 实例，每个Foo 实例的构造函数使用类SlowObject 的静态实例作为锁，实例化需要500 毫秒。尽管如此，SlowObject 总是在任何Foo 构造函数启动之前创建。我使用各种版本的 .NET Framework、C# 版本 4、5、6 和 7 测试了这个程序，同时带有 Debug 和 Release 配置，并带有和不带有调试器。输出始终相同。注释掉静态构造函数没有区别。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Threading;

class Program
{
    static Program()
    {
        Program.ConsolePrint("Program Static Constructor");
    }

    static void Main(string[] args)
    {
        ConsolePrint("Starting Tasks");
        var tasks = Enumerable.Range(1, 5).Select(n => Task.Run(() =>
        {
            new Foo(n.ToString());
        })).ToArray();
        ConsolePrint("Waiting Tasks");
        Task.WaitAll(tasks);
        ConsolePrint("Tasks Finished");
        //Console.WriteLine("Foo.list: " + String.Join(", ", Foo.GetItems()));
    }

    public static void ConsolePrint(string line)
    {
        Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " ["
            + Thread.CurrentThread.ManagedThreadId.ToString() + "] > " + line);
    }
}

public class Foo
{
    static Foo()
    {
        Program.ConsolePrint("Foo Static Constructor");
    }

    private static List<string> list = new List<string>();
    private static object listLock = new SlowObject();

    public Foo(string s)
    {
        Program.ConsolePrint("Creating Foo " + s);
        lock (listLock)
        {
            list.Add(s);
        }
    }
}

public class SlowObject
{
    static SlowObject()
    {
        Program.ConsolePrint("SlowObject Static Constructor");
    }

    public SlowObject()
    {
        Program.ConsolePrint("SlowObject Instance Constructor Started");
        Thread.Sleep(500);
        Program.ConsolePrint("SlowObject Instance Constructor Finished");
    }
}

输出：

13:40:24.091 [1] > Program Static Constructor
13:40:24.112 [1] > Starting Tasks
13:40:24.131 [1] > Waiting Tasks
13:40:24.132 [3] > SlowObject Static Constructor
13:40:24.133 [3] > SlowObject Instance Constructor Started
13:40:24.635 [3] > SlowObject Instance Constructor Finished
13:40:24.635 [3] > Foo Static Constructor
13:40:24.637 [3] > Creating Foo 1
13:40:24.637 [4] > Creating Foo 2
13:40:24.643 [3] > Creating Foo 5
13:40:24.639 [5] > Creating Foo 3
13:40:24.641 [6] > Creating Foo 4
13:40:24.647 [1] > Tasks Finished
Press any key to continue . . .