Do both of these constructors do the same thing?

Question

Do both of these code blocks do the same thing?

class A {
   public static int s;
   A(){}
   static A(){s = 100;}
}

and

class A {
   public static int s=100;
   A(){}
   //static A(){s = 100;} do not use
}

Do they do the same thing? I think so.

In this case they will produce the same result after the fact, they'll simply do it in different ways. — David, Sep 30 '14 at 16:36
Please try to use the search and share what you have found. Everything the answers here repeat had been explained before. See http://stackoverflow.com/questions/8285168/why-static-fields-initialization-occurs-before-the-static-constructor, http://stackoverflow.com/questions/2761393/static-readonly-field-initializer-vs-static-constructor-initialization — CodeCaster, Sep 30 '14 at 16:40

score 11 · Accepted Answer · answered Sep 30 '14 at 16:36

No, they don't behave quite the same way. Without the static constructor, the timing of exactly when the type initializer executes is much looser - it can happen earlier or later than you'd expect.

When there's a static constructor, the type initializer executes when the type is first used in terms of any static member being accessed or any instance being created.

When there isn't a static constructor, the only guarantee is that the initializer will be executed at some point before the first access of a static field (and still exactly once). Depending on the JIT, that might mean it's executed very early (e.g. when you first execute a method which might use a member) or very late (after calling static members which don't use any fields, or after creating and using an instance).

In IL, the difference is that a type without a static constructor has the beforefieldinit flag; one with a static constructor doesn't.

When both options are possible, which one do you usually prefer, with or without the static constructor definition? — Luca Cremonesi, Oct 02 '14 at 14:12
@LucaCremonesi: Usually I go with whichever's clearer - which is *typically* without a static constructor unless I'm doing significant work in initialization (which is usually a design smell anyway). — Jon Skeet, Oct 02 '14 at 14:17

D Stanley · Answer 2 · 2014-09-30T16:42:47.337

4

The effect is the same, but the actual order of execution may be different. When there is a static constructor, static fields are initialized immediately before the constructor is called or any of the static fields are accessed. If there is no static constructor, then the field initializers can be executed at any time prior to the first usage of one of the static fields.

Since your initializers have no side-effects and cannot throw exceptions, there would not be any discernable difference in the two, barring the use of reflection or some other outside observer (e.g. debugger)

edited Sep 30 '14 at 16:42

answered Sep 30 '14 at 16:37

D Stanley

149,601
11
178
240

Not quite: when there's a static constructor, it's immediately before the constructor is called or any static member. When there isn't a static constructor, it's before any access to a *static* field - using an instance field doesn't have to trigger the initializer. – Jon Skeet Sep 30 '14 at 16:41

Tim S. · Answer 3 · 2014-09-30T16:42:44.153

Except for some edge cases such as beforefieldinit behavior, yes, they do the same thing. In fact, the compiled IL is nearly the same in the two cases. The only difference is the presence of beforefieldinit on the one without a static constructor.

class A
{
    public static int s;
    A() { }
    static A() { s = 100; }
}

class B
{
    public static int s = 100;
    B() { }
}

Compiles to...

.class private auto ansi A
    extends [mscorlib]System.Object

.class private auto ansi beforefieldinit B
    extends [mscorlib]System.Object

With identical method/field definitions.

score 0 · Answer 4 · answered Sep 30 '14 at 16:47

According to C# in a Nutshell the static constructor is executed when you first use of the property, and the most usage of this is when you want to calculate or read some data and set to the static property (Like a password from appconfig.config). without using the static constructor you must define a Init method and call it when your application has been started.

Do both of these constructors do the same thing?

4 Answers4