How to catch or flag potential problems due to the order of static field initialization

Question

Consider the following C# code:

using System;
class Program
{
    static string string1 = "AAA";
    static string string2 = string1 + string3;
    static string string3 = "BBB";

    static void Main()
    {
        Console.WriteLine(string2);
    }
}

I wrote some code like this earlier today and was expecting string2 to contain the value AAABBB, but instead it just contained AAA. I did some reading on the order of initialization of static variables, but it seems preferable to me that some type of warning or error would have been generated during compilation.

Two questions:

1. Why is such code allowed to compile successfully? (and if the answer is: "because that's how the C# spec is written", then why was it written that way? Are there reasons I'm missing why this doesn't preferably always just throw a compile-time error?)

2. Is there any way to get a compile-time warning or some other kind of flag if I end up inadvertently writing this kind of code again in the future?

Answer 1

For question 2:

Tools like ReSharper catch these things. There might be a setting inside of Visual Studio that you can turn on for more verbose compilation output.

Here's the code after the Reshaper cleanup that produces "AAABBB"

class Program
    {
        private const string String1 = "AAA";
        private const string String2 = String1 + String3;
        private const string String3 = "BBB";

        static void Main()
        {
            Console.WriteLine(String2);
            Console.ReadLine();

        }

    }

As a side note, I'd say since we usually read from top to bottom it seems logical for the initialization to happen the same way as described in 10.4.5.1 of the C# specification.

Answer 2

If you think of your static initializers as logically part of the static constructor, things make a lot more sense. In your case, it's just as if you had written:

private static string String1;
private static string String2;
private static string String3;

static Program()
{
    String1 = "AAA";
    String2 = String1 + String3;
    String3 = "BBB";
}

The reason that static initializers don't work the way you want is that it's impossible in the general case for the compiler to reorder things. It could in this case, and in many others. But if you consider second-order effects such as I mentioned in my answer to a similar question, the compiler can't reliably reorder anything.

It would be confusing in the extreme for the compiler to do that reordering "sometimes."

Answer 3

As to #1: The reason that the code is allowed to compile is because, according to 10.4.5.1 of the C# spec, "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." That means that your string2 variable is unambiguously initialized to "AAA" + null. It's arguable that you should at least get a warning... as to why your IDE chose not to warn you, I don't know.

With regards to #2: I don't know. This seems like a question that would be more appropriately if tagged with your IDE as well.

Answer 4

It's by design.

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.

C# has a definite assignment policy which means that, for example, fields are initialized automatically. Therefore your string3 is automatically initialized to null and so, as far as the compiler is concerned, it already has value.

This means the output of string2 is string1 + null (which is simply string2) and so there is no reason for the compiler to throw any errors (although I do see how a warning for this would be useful).