Require all base class static constructors to run when calling a static function on a class

[cdaley0]

Consider the following code

using System;

class A
{
    static A() => Console.WriteLine("A");

    protected static void Func1() => Console.WriteLine("Func1");
}

class B : A
{
    static B() => Console.WriteLine("B");
}

class C : B
{
    static C() => Console.WriteLine("C");

    public static void Func2() => Func1();
}

class Program
{
    public static void Main()
    {
        C.Func2();
    }
}

The output of this program when compiled and run on my computer and on .NET Lab is

C
A
Func1

The static constructor for class B is not being run. At first I thought this was a bug, but in the static constructors guide the following wording is used when describing static initialization: "...Any static constructors, from the ultimate base class of Object.Object through each base class through the type run. The order of static constructor execution isn't specified. However, all static constructors in the hierarchy run before any instances are created."

The wording specifies only that static constructors in the type's hierarchy are run before any instances of the type are created, so it appears that the output above is technically correct because no instances of class C have been created. If Func2 is changed to be an instance method and invoked via new C().Func2() then the static constructor for B is also run.

This behavior is counterintuitive. To have a class with two base types in its hierarchy and have the static constructor for the middle type skipped is quite confusing, even if technically allowed according to the language spec. I believe it would be a good idea to update the language so that all static constructors in the hierarchy run before any instances are created, or static functions/fields accessed. I don't know if this would cause any issues when it comes to multiple types inheriting from the same type.

[CyrusNajmabadi]

We would not be able to do this. It would certainly break code that doesn't expect these static constructors to run until actually needed.

The OP also doesn't seem to give a good reason for why this would be desirable. THe way things work now is that this code is run when needed, and the cost (and other impacts) of those constructors isn't paid until that point. Forcing extra work to be done runs counter to the desires/designs of the rest of the critical code that is executing (especially at important times like app loading).

[cdaley0]

I understand if it's not doable. My reasoning was that I expected static constructors to work similar to regular constructors when it comes to type class hierarchies. I made this post because I had some actual code similar to the snippet I posted that relied on all static constructors for a class' base types running when the static constructor for that class is invoked. I can definitely work around this limitation though.

It would certainly break code that doesn't expect these static constructors to run until actually needed.

As for this point, the static constructors guide seems to say only that the static constructor will run before any instances are created or fields accessed directly on the type. It does not appear to make any claim that the static constructor will not be run until the latest possible time that they can be. It also has the wording "The user has no control on when the static constructor is executed in the program". So from what I can tell, any code that relies on maximally lazy static constructors is relying on an implementation defined behavior that isn't formally guaranteed.

[chrisoverzero]

A root of the confusion may be that a C# syntactic nicety is making you think of inheritance when static is used. C actually looks like this:

class C : B
{
    static C() => Console.WriteLine("C");

    public static void Func2() => A.Func1(); // <==
}

…so B isn’t involved in the method calls at all.