How can I run a static initializer method in C# before the Main() method?

Question

Given a static class with an initializer method:

public static class Foo
{
    // Class members...

    internal static init()
    {
        // Do some initialization...
    }
}

How can I ensure the initializer is run before Main()?

The best I can think of is to add this to Foo:

private class Initializer
{
    private static bool isDone = false;
    public Initializer()
    {
        if (!isDone)
        {
            init();
            isDone = true;
        }
    }
}

private static readonly Initializer initializer = new Initializer();

Will this work or are there some unforeseen caveats? And is there any better way of doing this?

Answer 1

Simply do the initialization inside a static constructor for Foo.

From the documentation:

A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced.

Answer 2

There are static constructors in C# that you can use.

public static class Foo
{
    // Class members...

    static Foo(){
        init();
        // other stuff
    }

    internal static init()
    {
        // Do some initialization...
    }
}

Answer 3

Move your code from an internal static method to a static constructor, like this:

public static class Foo
{
  // Class members...

  static Foo()
  {
    // Do some initialization...
  }
}

This way, you are quite sure that the static constructor will be run on first mention of your Foo class, whether it's a construction of an instance or access to a static member.

Answer 4

Place your initialization code in the static constructor of the class

static Foo()
{
    // Initialization code
}

This constructor is run the first time the class is accessed.

You can use RunClassConstructor to trigger the static constructor of the class before using a class. This can be useful if, for instance, this class registers itself in a IOC container or something like this.

RuntimeHelpers.RunClassConstructor(typeof(Foo).TypeHandle);

You find the RuntimeHelpers in the System.Runtime.CompilerServices namespace.

C# 9.0 added Module Initializers allowing you to write initialization code for the assembly with no need to explicitly call anything.

Apply the [ModuleInitializer] attribute to a static void parameterless method to make it a module initializer.

[ModuleInitializer]
internal static void MyAssemblyInitializer()
{
    // ...
}