29

While working on a C# app I just noticed that in several places static initializers have dependencies on each other like this:

static private List<int> a = new List<int>() { 0 };
static private List<int> b = new List<int>() { a[0] };

Without doing anything special that worked. Is that just luck? Does C# have rules to resolve this?

Edit: (re: Panos) In a file lexical order seems to be king? what about across files?

In looking I tried a cyclical dependency like this:

static private List<int> a = new List<int>() { b[0] };
static private List<int> b = new List<int>() { a[0] };

and the program didn't run the same (the test suit failed across the board and I didn't look further).

Improve this question
3
  • I think that across files (i.e. across different classes) it will happen the same. During the type initialization of class A, class B will be asked to initialize, and class B will find a null reference to class A. Commented Oct 9, 2008 at 0:06
  • Now, across files of same class (partial class), probably is up to the pre-processor to determine if it fails or not. Commented Oct 9, 2008 at 0:07
  • So if A references B.b then A.a getting inited will bump B.b? Commented Oct 9, 2008 at 0:09

4 Answers 4

Reset to default
24

See §15.5.6.2: Variable initializers: Static field initialization of the current C# 8 draft spec for the current rules here:

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 (§15.5.6.1). Within a partial class, the meaning of “textual order” is specified by §15.5.6.1. If a static constructor (§15.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.

And specifically regarding partial types, §15.5.6.1 states:

When there are field declarations in multiple partial type declarations for the same type, the order of the parts is unspecified. However, within each part the field initializers are executed in order.

This was also stated in section 10.4 of the original language specification (archived) active at the time the question was asked:

when a class is initialized, all static fields in that class are first initialized to their default values, and then the static field initializers are executed in textual order. Likewise, when an instance of a class is created, all instance fields in that instance are first initialized to their default values, and then the instance field initializers are executed in textual order. It is possible for static fields with variable initializers to be observed in their default value state. However, this is strongly discouraged as a matter of style.

So in other words, in your example 'b' is initialized to its default state (null) and so the reference to it in the initializer of 'a' is legal but would result in a NullReferenceException.

These rules are different to Java's (see section 8.3.2.3 of the JLS for Java's rules about forward references, which are more restrictive).

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Great answer to the question I asked. However it seems I didn't ask the question I wanted to: what about across files?
I'm not a C# whiz (just knew where to look) but check out msdn.microsoft.com/en-us/library/aa645612(VS.71).aspx -- "It is possible to construct circular dependencies that allow static fields with variable initializers to be observed in their default value state". Does that help?
@Cowan not really. It doesn't address the cross file issue.
15

It seems to depend on the sequence of lines. This code works:

static private List<int> a = new List<int>() { 1 };
static private List<int> b = new List<int>() { a[0] };

while this code does not work (it throws a NullReferenceException)

static private List<int> a = new List<int>() { b[0] };
static private List<int> b = new List<int>() { 1 };

So, obviously no rules for cyclical dependency exist. It's peculiar however that the compiler does not complain...

EDIT - What's happening "across files"? If we declare these two classes:

public class A {
    public static List<int> a = new List<int>() { B.b[0] };
}
public class B {
    public static List<int> b = new List<int>() { A.a[0] };
}

and try to access them with this code:

try { Console.WriteLine(B.b); } catch (Exception e) { Console.WriteLine(e.InnerException.Message.); }
try { Console.WriteLine(A.a); } catch (Exception e) { Console.WriteLine(e.InnerException.Message); }
try { Console.WriteLine(B.b); } catch (Exception e) { Console.WriteLine(e.InnerException.Message); }

we are getting this output:

The type initializer for 'A' threw an exception.
Object reference not set to an instance of an object.
The type initializer for 'A' threw an exception.

So the initialization of B causes an exception in static constructor A and lefts field a with the default value (null). Since a is null, b can not also be initialized properly.

If we do not have cyclical dependencies, everything works fine.

EDIT: Just in case you didn't read the comments, Jon Skeet provides a very interesting reading: The differences between static constructors and type initializers.

Improve this answer

2 Comments

This is sure. The static constructor is called when the type is referenced for the first time.
Be careful here about the difference between static variable initializers and static constructors. There are different rules around when type initialization occurs based on the presence/absence of a static constructor. See pobox.com/~skeet/csharp/beforefieldinit.html
2

Personally I would get rid of the static initializers since it isn't clear and add a static constructor to initialize these variables. 

static private List<int> a;
static private List<int> b;

static SomeClass()
{
    a = new List<int>() { 0 };
    b = new List<int>() { a[0] };
}

Then you don't have to guess what is going on and you're being clear in your intentions.

Improve this answer

1 Comment

Note that those pieces of code aren't exactly equivalent in terms of when they run: pobox.com/~skeet/csharp/beforefieldinit.html
0

Yes, you were lucky. C# appears to execute the code in the order it appears in the class.

static private List<int> a = new List<int>() { 0 };
static private List<int> b = new List<int>() { a[0] };

Will work but ... 

static private List<int> b = new List<int>() { a[0] };
static private List<int> a = new List<int>() { 0 };

Will fail.

I would recommend putting all your dependencies in one place, the static constructor is the place for this.

static MyClass()
{
  a = new List<int>() { 0 };
  b = new List<int>() { a[0] };
}
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.