Does the order of fields in C# matter?

Question

This question is inspired by Jon Skeet's answer: Is there a c# equivalent to c++'s access-modifier regions

He makes a comment that it is possible for the order of fields in a file to matter. I am guessing that this has to do with the order that the fields are initialized, but I think it's a dangerous enough thing to code based on this side effect that it warranted its own question and discussion.

Are there other thoughts around how the order of fields within your code file could be manipulated and what impact that might have?

Answer 1

You can use (abuse?) the order of fields as metadata of your class which you can than read via reflection.

for example, if you have a class that represents a network protocol with fields ID, PORT, and XOR, in that order, you could define it as:

class MyProtocol {
    int ID;
    int PORT;
    int XOR;
}

Now suppose you use reflection to iterate the fields of the protocol, to send over the wire. The order returned by GetProperties will be as you defined, and you didn't have to write any extra metadata explicitly.

Not sure if it's a good idea though to depend on this.

Answer 2

Yeah, it does matter when interfacing with unmanaged code.

Answer 3

I believe XmlSerializer serializes members in the order they appear in the source file.

Answer 4

If fields are initialized as part of the declaration, they are added to the constructor (instance or static) in the order they appear in the file.

Answer 5

I was primarily thinking about the order of initialization, yes - particularly for static fields. For instance (with public fields just for simplicity of demonstration):

using System;

class First
{
    static int a = 10;
    public static int b = CalculateB();
    static int c = 5;

    static int CalculateB()
    {
        return a*c;
    }
}

class Second
{
    static int a = 10;
    static int c = 5;
    public static int b = CalculateB();

    static int CalculateB()
    {
        return a*c;       
    }
}

class Test
{
    static void Main()
    {
        Console.WriteLine("First.b: {0}, Second.b: {1}",
                          First.b, Second.b);
    }
}

The order of initialization is defined in the spec to be the textual order in which the variables are declared - but it becomes undefined when two variables are in different files contributing to a partial class.

Mehrdad's answer is another good one: anything where physical layout is important will quite possibly be affected by declaration order.

Answer 6

Here is a classic example from the C# language spec (Section 10.5.5)

class Test
{
    static int a = b + 1;
    static int b = a + 1;
    static void Main() {
        Console.WriteLine("a = {0}, b = {1}", a, b);
    }
}

This is a completely valid program and as written (a = 1, b =2). However if you swap the ordering of the fields they will also swap values.