我的 C# 程序没有按照我认为的对象初始化顺序初始化对象。 为什么？

Question

I believe the Object Initialization order of C# goes like this:

• Derived static fields
• Derived static constructor
• Derived instance fields
• Base static fields
• Base static constructor
• Base instance fields
• Base instance constructor
• Derived instance constructor

Below you see a simple test program and the output it produces when I run it.

    public class UiBase
    {
        protected static string Something = "Hello";

        public UiBase()
        {
            Console.WriteLine(this.ToString());
        }
    }

    public class Point : UiBase
    {
        private int X = -1;
        private int Y = -1;

        static Point()
        {
            Something = "Bar";
        }

        public Point(int x, int y)
        {
            X = x;
            Y = y;
        }

        public override string ToString()
        {
            return $"Point:{X}/{Y}/{Something}";
        }
    }

    public static class Program{
    public static void Main(){
        var x = new Point(2,1);
        Console.WriteLine(x);
    }
on Console:
Point:-1/-1/Bar
Point:2/1/Bar

When I think about how it should happen according to the list above, I believe it should be like this:

1. Point static field (none in my case?)
2. Point static constructor -> sets Something to "Bar"
3. Point instance fields
4. Base static fields -> sets Something back to "Hello"? ...

However it does NOT set Something back to Hello which really confuses me. So how can I explain this? or is the Object Initialization different from what I stated?

Answer 1

You call a virtual member ToString() in base UiBase class constructor

Console.WriteLine(this.ToString());

It's being called before Point constructor

public Point(int x, int y)
{
     X = x;
     Y = y;
}

this isn't fully initialized yet, you are getting -1 in output. Since ToString() is virtual method, Point.ToString() is called, per specs

The overriding member in the most derived class is called, which might be the original member, if no derived class has overridden the member.

Static constructor is called automatically before the instance of Point is created or any static members are referenced (have a look at the static constructors for details)

static Point()
{
     Something = "Bar";
}

It'll overwrite Something from base class and you get Bar in output in both cases. Something is never set back to Hello , it's being overwritten only once.

Something field is entirely specific for UiBase , there is no copy in Point class, it's value will be changed everywhere. According to static members

Only one copy of a static member exists, regardless of how many instances of the class are created.

If you print UiBase.Something after Console.WriteLine(x); , you'll get Bar , not the Hello . There is only one exception, for generic classes, but it's out of scope of your question.

In terms of execution order all field initializers run in order from derived class to base, and then all constructors run in order from base to derived (this is correct for instance members). I've added a steps for all your operations to see the actual order.

public class UiBase
{
    private static int temp = Step("uibase static field init");
    public static string Something = "Hello";

    private int _temp = Step("uibase instance field init");

    public static int Step(string message)
    {
        Console.WriteLine(message);
        return 0;
    }

    public UiBase()
    {
        Step("uibase instance ctor");
        Console.WriteLine(this.ToString());
    }
}

public class Point : UiBase
{
    private int _temp = Step("point instance field init");

    private int X = -1;
    private int Y = -1;

    static Point()
    {
        Step("point static ctor before");
        Something = "Bar";
        Step("point static ctor after");
    }

    public Point(int x, int y)
    {
        Step("point instance ctor");

        X = x;
        Y = y;
    }

    public override string ToString()
    {
        return $"Point:{X}/{Y}/{Something}";
    }
}

the output will be the following

point static ctor before
uibase static field init
point static ctor after
point instance field init
uibase instance field init
uibase instance ctor
Point:-1/-1/Bar
point instance ctor
Point:2/1/Bar

The Point static constructor is invoked first (there is no static fields in Point class), then it'll 'ask' UiBase init a static fields, because accessing its Something value (it's set to Hello ), after that Something is set to Bar and execution continues to instance initialization (again, Something never changes anymore) - derived class fields, base class fields, base class constructor and derived class constructor.

I think, only first 3 lines can be confusing a little bit, but static initialization happens only once and before any instance initialization. The order of static initialization is determined by compiler based on your actual code.

Adding a UiBase static constructor can make the picture more clear actually, in this case UiBase static members will be initialized before Point static initialization.