CODEWITHSUNDEEP
c#.net
Dr Mojo
Dr Mojo

Reputation: 53

When do static fields come into existence?

I'm trying to understand when exactly static fields come into existence and have been reading this MSDN article - http://msdn.microsoft.com/en-us/library/79b3xss3 - but it seems to contradict itself:

First it says:

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.

But then it goes on to say:

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

So, my question is basically this: When are static fields actually initialized and when do they first come into existence? Is it before the static constructor is called, during, or after?

Many thanks!

Upvotes: 5

Views: 1575

Answers (4)

xanatos
xanatos

Reputation: 111870

It's like "normal" fields. So before the static constructor. You can check with a very simple program.

The order is:

  • static fields
  • static constructor
  • "normal" fields
  • "normal" constructor

A sample program:

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Start");
        int b = A.B;
        Console.WriteLine("Read A.B");
        new A();
        Console.WriteLine("Built A");
    }
}

class A
{
    public static int B = mystaticfunc();

    static int mystaticfunc() {
        Console.WriteLine("Static field");
        return 1;
    }

    static A()
    {
        Console.WriteLine("Static constructor");
    }

    int C = myfunc();

    static int myfunc()
    {
        Console.WriteLine("Field");
        return 1;
    }

    public A()
    {
        Console.WriteLine("Constructor");
    }
}

Output:

Start
Static field
Static constructor
Read A.B
Field
Constructor
Built A

Upvotes: 2

Reed Copsey
Reed Copsey

Reputation: 564433

The C# Language specification states (in 10.5.5.1 Static field initialization):

The static field variable initializers of a class correspond to a sequence of assignments that are executed in the textual order in which they appear in the class declaration. If a static constructor (§10.12) exists in the class, execution of the static field initializers occurs immediately prior to executing that static constructor. Otherwise, the static field initializers are executed at an implementation-dependent time prior to the first use of a static field of that class

I believe the guidance in your second line is actually to initialize static fields that are not done inline, using field initializers. In that case, you should use a static constructor to guarantee that they will be initialized prior to usage.

As you can see from the specification, the actual "time" they come into existence is implementation specific, and subject to change. The only guarantee is that they will exist prior to the static constructor being called, which will always occur prior to their usage in code. This specification states (in 10.12):

The execution of a static constructor is triggered by the first of the following events to occur within an application domain:

· An instance of the class type is created.

· Any of the static members of the class type are referenced.

Upvotes: 8

Ben Voigt
Ben Voigt

Reputation: 283684

The CLR doesn't have separate concepts of static member initialization and static constructor. Instead, there's just a single type initializer.

The C# compiler writes this type initializer for you, first it does initialization of static members, then it includes your code from any static constructor you defined.

Upvotes: 1

Jonathan Wood
Jonathan Wood

Reputation: 67213

Static fields are guaranteed to be initialized prior to the first use of the class.

Optionally, you can provide a static constructor to control static initialization at the time it occurs.

Upvotes: 1

Related Questions