CODEWITHSUNDEEP
c#unity-game-engine
Gensys LTD
Gensys LTD

Reputation: 133

C# Unity > Static instance member not causing constructor to be called

I have noticed a rather weird behaviour in my application I am creating;

I have a class I defined that has a static "instance" variable of the class type.

I would assume that (as per code attached) the constructor would be called.

Alas, it is not, unless I use the Void.get in a non-static field anywhere in my code.

public class Void : TilePrototype {

public static Tile get = new Tile((int)TileEntities.Void);
public static Void instance = new Void();

public Void() {
    Debug.Log("created");
    id = (int)TileEntities.Void;
    isBlocking = true;
    register();
}

public override RenderTile render(Tile tile){
    return new RenderTile(0, new Color(0, 0, 0, 0));
}

So when I have something like :

    public static TileStack empty = new TileStack(Void.get, Void.get);

the Void class constructor never gets called. But, if I have:

Tile t = Void.get;

Anywhere in my code it will be called.

Why?

Thanks.

Upvotes: 3

Views: 2052

Answers (2)

Gensys LTD
Gensys LTD

Reputation: 133

Thanks to Marc Gravell's aswer I came up with this contraption (and admittedly I do like the new solution more than the old one, so thanks again!)

Modifications done to the Void class:

public class Void : TilePrototype {
public static Void instance = new Void();
public static Tile get {
    get {
        return new Tile(instance.id);
    }
}

public Void() {
    isBlocking = true;
}

public override RenderTile render(Tile tile){
    return new RenderTile(0, new Color(0, 0, 0, 0));
}
}

So as You can see I made the "get" variable a property, so that it's evaluated later, when you actually need the tile, not on construction. I've changed all "get"s this way.

Second change is in the TilePrototype:

public class TilePrototype {
public static Dictionary<int, TilePrototype> tilePrototypeDictionary = new Dictionary<int, TilePrototype>();

public static void registerPrototype(int id, TilePrototype tp){
    tp.id = id;
    tilePrototypeDictionary.Add(id, tp);
}

public static bool registered = false;

public static void registerAll(){
    if( registered ) return;
    registerPrototype(0, Void.instance);
    registerPrototype(1, Air.instance);
    registerPrototype(2, Floor.instance);
    registerPrototype(3, Wall.instance);

(...)

Here I've added the registerPrototype and registerAll functions.

This gives me easy access to all the registered type ids (by say Wall.instance.id) as well as the other way around (from id to instance via the Dictionary)

I also have all registered things in one place, with the possibility of runtime adding more

Overall, much neater, and here I assure that all tiles are registered properly and assigned proper IDs.

Change of ID is simple and in one place and everywhere else, access to this ID is done via a short .instance.id

Thanks again for the help :)

Upvotes: 0

Marc Gravell
Marc Gravell

Reputation: 1062705

This is a really really subtle and nuanced area of C#; basically, you've stumbled into "beforefieldinit" and the difference between a static constructor and a type initializer. You can reasonably ask "when does a static constructor run?", and MSDN will tell you:

It is called automatically before the first instance is created or any static members are referenced.

Except... public static TileStack empty = new TileStack(Void.get, Void.get); isn't a static constructor! It is a static field initializer. And that has different rules, which basically are "I'll run when I must, no later, possibly sooner". To illustrate with an example: the following will not (probably) run your code, because it doesn't have to - there isn't anything demanding the field:

class Program
{
    static void Main()
    {
        GC.KeepAlive(new Foo());
    }
}

public class Foo
{
    public static TileStack empty = new TileStack(Void.get, Void.get);
}

However, if we make a tiny tweak:

public class Foo
{
    public static TileStack empty = new TileStack(Void.get, Void.get);
    static Foo() { } // <=== added this
}

Now it has a static constructor, so it must obey the "before the first instance is created" part, which means it needs to also run the static field initializers, and so on and so on.

Without this, the static field initializer can be deferred until something touches the static fields. If any of your code actually touches empty, then it will run the static field initializer, and the instance will be created. Meaning: this would also have this effect:

class Program
{
    static void Main()
    {
        GC.KeepAlive(Foo.empty);
    }
}

public class Foo
{
    public static TileStack empty = new TileStack(Void.get, Void.get);
}

This ability to defer execution of the static initialization until the static fields are actually touched is called "beforefieldinit", and it is enabled if a type has a static field initializer but no static constructor. If "beforefieldinit" isn't enabled, then the "before the first instance is created or any static members are referenced" logic applies.

Upvotes: 7

Related Questions