How does a static constructor work?

Question

namespace MyNameSpace
{
    static class MyClass
    {
        static MyClass()
        {
            //Authentication process.. User needs to enter password
        }

        public static void MyMethod()
        {
            //Depends on successful completion of constructor
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyClass.MyMethod();
        }
    }
}

Here is the sequence which I assumed

Start of static constructor
End of static constructor
Start of main
Start of MyMethod
End of main

Now in any scenario if 4 will start before 2 I am screwed. Is it possible?

Is this a java or c# question ? You've put both tags, and I don't think the specification is the same in the two languages. — ARRG, Feb 22 '12 at 16:13
In my openion this is work same for both.. But I am C# guy.. Sry for that — om471987, Feb 22 '12 at 16:15
Java doesn't have a static constructor in the same way, just static blocks for static initialization. static { //do something... } — deraj, Feb 22 '12 at 16:20
Personally, I feel uncomfortable with any form of interactivity inside a static constructor. I understand your goal (make every method in this static class wait until the user is authorized before allowing it to run), but really dislike this method of accomplishing it. — Brian, Feb 22 '12 at 18:11
@Brian:- Yeah... You are right... I was just doing analysis.. Finally I just decided not to use constructor but Initialize method — om471987, Mar 08 '12 at 17:44

score 223 · Accepted Answer · edited May 08 '14 at 09:45

You only asked one question here but there are a dozen or so questions that you should have asked, so I'll answer them all.

Here is the sequence which I assumed

Start of class constructor (also known as cctor)
End of cctor
start of Main
start of MyMethod

Is this correct?

No. The correct sequence is:

Start of cctor for Program, if there is one. There is not.
End of cctor for Program, if there is one. There is not.
Start of Main
Start of cctor for MyClass
End of cctor for MyClass
Start of MyClass.MyMethod

What if there is a static field initializer?

The CLR is permitted to change the order in which static field initializers run in some cases. See Jon's page on the subject for details:

The differences between static constructors and type initializers

Is it ever possible for a static method like MyMethod to be called before the cctor of that class completes?

Yes. If the cctor itself calls MyMethod then obviously MyMethod will be called before the cctor completes.

The cctor does not call MyMethod. Is it ever possible for a static method like MyMethod to be called before the cctor of MyClass completes?

Yes. If the cctor uses another type whose cctor calls MyMethod then MyMethod will be called before the MyClass cctor completes.

No cctors call MyMethod, directly or indirectly! Now is it ever possible for a static method like MyMethod to be called before the cctor of MyClass completes?

No.

Is that still true even if there are multiple threads involved?

Yes. The cctor will finish on one thread before the static method can be called on any thread.

Can the cctor be called more than once? Suppose two threads both cause the cctor to be run.

The cctor is guaranteed to be called at most once, no matter how many threads are involved. If two threads call MyMethod "at the same time" then they race. One of them loses the race and blocks until the MyClass cctor completes on the winning thread.

The losing thread blocks until the cctor is done? Really?

Really.

So what if the cctor on the winning thread calls code that blocks on a lock previously taken by the losing thread?

Then you have a classic lock order inversion condition. Your program deadlocks. Forever.

That seems dangerous. How can I avoid the deadlock?

If it hurts when you do that then stop doing that. Never do something that can block in a cctor.

Is it a good idea to rely upon cctor initialization semantics to enforce complex security requirements? And is it a good idea to have a cctor that does user interactions?

Neither are good ideas. My advice is that you should find a different way to ensure that the security-impacting preconditions of your methods are met.

Eric, I am curious why you replaced "static constructor" with "class constructor" or "cctor" in this answer. Is it improper to use "static constructor" when referring to a cctor? — phoog, Feb 22 '12 at 21:23
@phoog: I wanted to be consistent in my use of terminology, so I picked the shortest one. "Static constructor" and "class constructor" are both fine. As an implementation detail, the static constructor of a type is emitted as a special method called ".cctor", so it is common to refer to such a constructor as "a cctor". Were I writing in a more formal context I'd use one of the longer terms. — Eric Lippert, Feb 22 '12 at 22:39
@EricLippert Is this also true for non-static classes with a static constructor? — Legends, Oct 15 '19 at 12:24
@Legends: *Is this also true for non-static classes with a static constructor?* Yes. — Eric Lippert, Oct 15 '19 at 13:29

score 24 · Answer 2 · answered Feb 22 '12 at 16:14

24

According to the MSDN, a static constructor:

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

So the static constructor will be called before the static method MyClass.MyMethod() is invoked (assuming not also invoked during static construction or static field initialization of course).

Now, if you are doing anything asynchronous in that static constructor, then it's your job to synchronize that.

answered Feb 22 '12 at 16:14

James Michael Hare

37,767
9
73
83

8

If you are doing anything asynchronous that involves a second thread in a static constructor, *you are in for a world of pain*. Nothing makes deadlocks faster. See http://stackoverflow.com/a/8883117/88656 for an example. – Eric Lippert Feb 22 '12 at 16:41
@Eric: agreed... I wouldn't want to do that, but wasn't sure form his example what exactly he was wanting to be finished by the time MyMethod was called... – James Michael Hare Feb 22 '12 at 16:50

score 11 · Answer 3 · answered Feb 22 '12 at 16:13

11

The #3 is actually #1: static initialization does not start until the first use of the class to which it belongs.

It is possible if MyMethod is called from the static constructor or a static initialization block. If you do not invoke MyMethod directly or indirectly from your static constructor, you should be fine.

answered Feb 22 '12 at 16:13

Sergey Kalinichenko

714,442
84
1,110
1,523

Just as a note, it's my understanding that the `static` initialization can actually be called before first use depending on eligibility for optimizations. – James Michael Hare Feb 22 '12 at 16:18
@JamesMichaelHare according to MS docs, ["The execution of a static constructor is triggered by the first of the following events to occur within an application domain: (1) An instance of the class is created. (2) Any of the static members of the class are referenced."](http://msdn.microsoft.com/en-us/library/aa645612%28v=vs.71%29.aspx) – Sergey Kalinichenko Feb 22 '12 at 16:25
1

For a static constructor, true, but for static initialization was my point. Sorry, maybe I was just picking nits on the phrase 'static initialization does not start...' that's true for static construction, but not if the class doesn't have a static constructor, then static initialization may happen before. – James Michael Hare Feb 22 '12 at 16:28
Sorry, I'm probably just overanalyzing the verbiage. In the context of the question it's absolutely correct, I was just worried about that sentence as a stand-alone statement for static initialization in the context of classes without explicit static constructors. – James Michael Hare Feb 22 '12 at 16:31
@James: You're not overanalysing - the terminology is the crucial difference here. Static constructors are a C# concept, whereas type initialisation is a .NET thing. The code inside a static constructor (C#) becomes part of the type initialiser (.NET), but *when* and *how* the type initialiser triggers (ie, the `beforefieldinit` semantics) is determined by whether or not the C# class has a static constructor. – LukeH Feb 22 '12 at 16:36
@JamesMichaelHare: See Jon's page for a thorough discussion of what optimizations are permitted and when: http://csharpindepth.com/Articles/General/Beforefieldinit.aspx – Eric Lippert Feb 22 '12 at 17:42

score 9 · Answer 4 · answered Feb 22 '12 at 16:15

9

From the documentation (emphasis mine):

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

answered Feb 22 '12 at 16:15

qxn

17,162
3
49
72

score 2 · Answer 5 · answered Feb 22 '12 at 16:15

2

You can guarantee 4 will always come after 2 (if you don't create a instance of your class from your static method), however the same is not true for 1 and 3.

answered Feb 22 '12 at 16:15

Scott Chamberlain

124,994
33
282
431

score 2 · Answer 6 · answered Feb 22 '12 at 16:15

2

The static constructor will be called before mymethod is executed. However if you are screwed if 4 is called before 2 then I suggest you re-think your design. Should not be doing complicated stuff in a static constructor anyway.

answered Feb 22 '12 at 16:15

Umair

3,063
1
29
50

score 2 · Answer 7 · answered Feb 22 '12 at 16:16

The CLR guarantees that the static constructor runs before any static members are accessed. However, your design is a bit smelly. It would be more straightforward to do something like this:

static void Main(string[] args) 
{ 
     bool userIsAuthenticated = MyClass.AuthenticateUser();
     if (userIsAuthenticated)
         MyClass.MyMethod(); 
 }

With your design, if authentication fails, the only way to prevent MyMethod from running is by throwing an exception.

haiyyu · Answer 8 · 2012-02-22T16:25:03.903

2

It's ensured that a static class's constructor has been called before any of its methods get executed. Example:

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Press enter");
        Console.ReadLine();
        Boop.SayHi();
        Boop.SayHi();
        Console.ReadLine();
    }

}

static class Boop
{
    static Boop()
    {
        Console.WriteLine("Hi incoming ...");
    }

    public static void SayHi()
    {
        Console.WriteLine("Hi there!");
    }
}

Output:

Press enter

// after pressing enter

Hi incoming ...

Hi there!

Hi there!

edited Feb 22 '12 at 16:25

answered Feb 22 '12 at 16:18

haiyyu

2,194
6
22
34

using System; namespace MyNameSpace { class Program { static void Main(string[] args) { Console.WriteLine("Entered in main"); Boop.SayHi(); Boop.SayHi(); } } static class Boop { static Boop() { Console.Read(); Console.WriteLine("Constructor key entered"); } public static void SayHi() { Console.WriteLine("Method is called"); } } } yeah this program gives better understanding – om471987 Feb 22 '12 at 16:26
Possibly. Next time post it as an answer, though. It's more helpful and visible then. – haiyyu Feb 22 '12 at 16:29

score 1 · Answer 9 · 2015-06-02T01:36:31.813

1

Here's the actual order in which things go down:

Start of Main
Start of the static MyClass constructor
End of the static MyClass constructor
Start of MyMethod
End of Main

edited Jun 02 '15 at 01:36

answered Mar 03 '12 at 02:47

score 0 · Answer 10 · answered Feb 29 '12 at 19:49

0

Or you could step through in the debugger.

answered Feb 29 '12 at 19:49

saille

9,014
5
45
57

How does a static constructor work?

10 Answers10

Linked