-1

I was reading MSDN Documentation and there seems to be a contradiction.

Static members are initialized before the static member is accessed for the first time and before the static constructor, if there is one, is called.

also in the next paragraph or so,

If your class contains static fields, provide a static constructor that initializes them when the class is loaded.

If static constructor's purpose is to initialize static members of the class then how come it says that static members get initialized even before static constructor gets called?

Is it like if I write:

public  static int age = 10;

static SimpleClass()
{
 age = 20;
}

Does that mean that age first gets initialized to 10 and then the value is overwritten to 20?

SamuraiJack
  • 5,131
  • 15
  • 89
  • 195

1 Answers1

2

The second quote is a recommendation: Microsoft recommends using the static constructor instead of initializing fields when declaring, to avoid ordering issues, especially when using partial classes, which can cause null exceptions.

Indeed, by using partial classes, the order of assignment of the fields is not guaranteed. Using the static constructor, it does.

You can also use properties to make sure that you don't get a null exception if the getters don't access instances of uninitialized reference types.

So, because of the first quote, the answer to your question is: yes, it means that age first gets initialized to 10 and then the value is overwritten to 20, unless you are using partial classes, then the result may be hazardous and it can be a fight against the debugger...

You can check and inversigate this by playing around with breakpoints.

  • Is the remark about `partial` classes not only relevant if a field initializer refers another field? Like, if I have (in the same "part" of a class) `static int a = 10 + b; static int b = 10 + a;`, then the two initializations are guaranteed to run in "textual" order, so because I declared `a` first, its initializer runs first, and will see `b` before it is initialized, so `a` becomes `10+0`, so `10`; while `b` becomes `10+10`, so `20`. If you put `a` and `b` in different files with different "parts" of a `partial` class, you risk that the "wrong" part is taken first, so `a` is `20`; `b` `10`. – Jeppe Stig Nielsen Jan 24 '21 at 23:09