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

<pre><code>static private List&lt;int&gt; a = new List&lt;int&gt;() { 0 };
static private List&lt;int&gt; b = new List&lt;int&gt;() { a[0] };
</code></pre>

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

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

<p>In looking I tried a cyclical dependency like this:</p>

<pre><code>static private List&lt;int&gt; a = new List&lt;int&gt;() { b[0] };
static private List&lt;int&gt; b = new List&lt;int&gt;() { a[0] };
</code></pre>

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

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
.