C# - 从其他类的 static 构造函数访问字段时，不调用 Static 初始化程序

Question

I have the following struct

public struct RenderLayer : IComparable<RenderLayer>, IEqualityComparer<RenderLayer> {

    public static readonly RenderLayer Default = new(nameof(Default), RenderLayerManager.NextLayerId);
    
    public readonly string name;
    public readonly int id;
    
    public RenderLayer (string name, int id) {
        this.name = name;
        this.id = id;
        Log.Notice("Render layer constructor");
    }

    public int CompareTo (RenderLayer other) => id.CompareTo(other.id);

    public bool Equals (RenderLayer x, RenderLayer y) {
        return x.id == y.id;
    }

    public int GetHashCode (RenderLayer obj) {
        return obj.id;
    }

}

And a manager class that holds all RenderLayers (the default one added here + others added from user configuration)

public static class RenderLayerManager {

    public static int NextLayerId => nextLayerId++;
    
    private static int nextLayerId = 0;
    private static readonly List<RenderLayer> layers = new();

    static RenderLayerManager () {
        Log.Notice("Render layer manager constructor, before");
        layers.Add(RenderLayer.Default);
        Log.Notice("Render layer manager constructor, after");
    }

    public static Span<RenderLayer> Layers => CollectionsMarshal.AsSpan(layers);

}

The problem is when the Layers property is used it somehow contains one RenderLayer that is not initialized. The output of the Log.Notice calls is:

[Notice] Render layer manager constructor, before
[Notice] Render layer manager constructor, after
[Notice] Render layer constructor

As far as I understand static initialization the static field in RenderLayer should be initialized when it is first accessed (or before). But clearly it is being initialized after the RenderLayerManager's constructor is completed

Edit: I've made an example for it. At first it seemed to also have the error but now I can't reproduce it. I have no idea why my project still has this issue but this example is running as expected. https://dotnetfiddle.net/P4FJ7Q

Answer 1

What Blindy meant was many things. Avoiding mutable static state, avoiding singletons, avoiding depending on order of static initialization -- these are one of the basic rules of not insisting on making your life harder that in must be. In the code you presented, you "break" all of those three "rules", and, unsurprisingly, static initialization order somehow has biten you.

What you deduced from the log is wrong. RenderLayer is not "clearly it is being initialized after the RenderLayerManager's constructor is completed".

In fact, the log you provided proves, that it was FIRST to be executed. But not first to complete.

Look at this line, how does it execute? Precisely, please?

(..) readonly RenderLayer Default = new("blah", RenderLayerManager.NextLayerId);

It calls into RenderLayer constructor, but that's not all. It also passes parameters. And to be able to call the constructor, it HAS TO have the parameters' values' already computed. Then, how is the second parameter computed?

This means, that what has happened in your code was:

• compiler picked RenderLayout as the first to be initialized statically, for some reason
• RenderLayout initialization has started
• it tried to initialize first static field: Default
• it started preparing parameters' values' for constructor
• doing so, it tries to read RenderLayerManager class static property
• RenderLayerManager was not initialized yet
• RenderLayerManager initialization has started
• RenderLayerManager static nextLayerId is set to 0 (not really, but let's say it is..)
• RenderLayerManager static nextLayerId is initialized - List is created, its ctor is called, nextLayerId is set to that new list instance
• RenderLayerManager static ctor is called
• that ctor writes out BEGIN log line
• that ctor executes layers.add , or rather, wants
• that ctor prepares parameters for layers.add - accesses RenderLayer.Default
• RenderLayer is not initialized yet - but it is UNDER INITIALIZATION - so it's static initialization procedure IS NOT CALLED AGAIN
• RenderLayer.Default is read out and contains trash, I'd expect null
• that ctor writes out END log line
• static ctor of RenderLayerManager ends
• execution returns where it was, static init of RenderLayer continues preparing args for new() in RenderLayer
• RenderLayerManager.NextId is read (and getter executes, increments counter, etc)
• all parameters for new() are now ready
• RenderLayer ctor is called, does its thing, writes out third log line

The thing with static initialization is this - it is hard to trace. Tiny things can force picking different starting point than you'd expect. Things can be pulled and executed in the middle if they are needed. When things are under ongoing initialization, they are not guaranteed to be coherent, and so on. That's why it's best to avoid it as much as possible and instead rely on things easier to plan out.

Let's drop the argument about not using static, and not using singletons, that's an independent discussion. Let's focus on static initialization. Why do you use it?

Maybe you wanted to have it "lazy" - if "RenderLayer" AND "RenderLayerManager" were not used, they'd be not initalized. Maybe you wanted to have it surely initialized before setting up before everything else. Or some other reason. I don't know. But at least for those two things, there are other ways.

• for lazy initialization, on first access, there's the Lazy<T> class that does exactly this

• for "before everything else" you can just use the good old main(). Why rely on static initialization order to be able to guess what you wanted, when you can just have it just like you have it now, and just conceptually move the RL.Default = new(..) and RLM.layers.add(RL.Default) to main() before you run the game loop? You don't have to paste that code there, just wrap these pieces in methods and then in main() you can just write RLM.Initialize(); RL.Initialize(); RLM.Initialize(); RL.Initialize(); or something like that, and you will instantly see why the static initialization order is important and sometimes ends up in a chicken-and-egg problem you have here.

Then, solve the chicken and egg problem. For example, like this:

public static int Main()
{
    // lets be 'sure' that RLM is first to be init'ed
    RenderLayerManager.Initialize();
}

public struct RenderLayer : ...
{ 
    public static readonly RenderLayer Default;

    public static void Initialize()
    {
        Default = new(nameof(Default), RenderLayerManager.NextLayerId);
    }
    
    ...
    
    public RenderLayer (string name, int id) {
        ...
    }

    ...
}

public static class RenderLayerManager {
    public static void Initialize()
    {
        RenderLayer.Initialize();
        layers.Add(RenderLayer.Default);
    }
    
    ...

    static RenderLayerManager () {
        Log.Notice("Render layer manager constructor, before");
        // layers.Add(RenderLayer.Default); // ***
        Log.Notice("Render layer manager constructor, after");
    }

    ...
}

Note that leaving layers.add at the old place would probably be fine now, since RLM begins initializing first, and then would pull RL, but that would happen only after RLM's field init is completed - so counter would be already ready - but - really - we want to minimize dependency on static initialization order, and that's why I move it now to RLM.Initialize() , so any reader of this code has no problem in determinig what precedes and what follows.

Key points of my proposed changes (if I not bothed it):

• static init of RL does not touch RLM
• static init of RLM does not touch RL
• RL and RLM expose Initialize methods that do final steps that must touch the other class
• caller is responsible for calling RLM.Initialize early enough before rest of the code tries to use it