5

I'm working on a game here, and found this rather intriguing bug. Suppose you have this enum:

public enum ItemType 
{
    Food,
    Weapon,
    Tools,
    Written,
    Misc
};

a base class

public class BaseItem
{
    public string Name = "Default Name";

    public ItemType Type = ItemType.Misc;
}

and two instances of it:

Ins1 = new BaseItem
{
   Name = "Something",
   Type = ItemType.Food
};

Ins2 = new BaseItem
{
   Name = "Something too",
   Type = ItemType.Tools
}

This is what happened to me: The first instance's type would remain as pre-initialized in the base class, even though I specified in its constructor that I want the type to be Food. The 2nd instance's type would be set correctly to Tools.

IF, I added a new enum value BEFORE Food, such as:

public enum ItemType 
{
    Nothing,
    Food,
    Weapon,
    Tools,
    Written,
    Misc
};

Then the 1st instance's type would be, as expected, Food. The 2nd instance's type would also be correct.

What could have caused this behavior? To describe it in short, all instances whose Type had been set in the constructor to the first value of the enum, would actually go back to the value they had in the BaseItem definition. Adding an extra value before the first enum value solved the problem, apparently; but it IS wrong, so I'd like to know what could have caused the issue.

Thanks!

--- Later Edit --- In case this helps: not doing any initialization to the "Type" field inside of BaseItem, and leaving only the braces constructor do the initialization, everything works fine without adding the "Nothing" value to the enum.

Sorry about this; after some more digging, it seems it's an Unity-only bug. Some other people encountered it too. I have solved the problem; everyone gets a vote up from me, and I'll add my own answer; maybe some other Unity users will find it. Thanks a lot for your help and interest!

Improve this question
10
  • 8
    You don't have any constructors. Commented Nov 27, 2012 at 22:03
  • 6
    Your code runs fine for me. Please show us an SSCCE. Commented Nov 27, 2012 at 22:05
  • 1
    Firstly it's bad idea to use the Type name for the field because there is already the System.Type class defined before. Try to rename it and see. Also it's good to define the constructors explicitly. Commented Nov 27, 2012 at 22:05
  • 1
    Check VS project settings, also is enum defined in the same assembly as a class/code block? Have you removd any constant numeric values/etc before posting here? Commented Nov 27, 2012 at 22:12
  • 1
    @SLaks Regarding a constructor: When the user code provides zero instance constructors for a non-static class, the compiler will emit one parameterless instance constructor (which will be public for non-abstract classes), so that's not a problem. Commented Nov 27, 2012 at 22:19

5 Answers 5

Reset to default
2

In case there are other Unity users that search for info here, thinking it's some .NET behavior issue: It seems it's an Unity-only bug. Other people encountered it too. Just avoid any kind of initialization in the class itself for this kind of stuff, or use properties.

It's definitely not a Microsoft .NET issue, and also not a Mono .NET issue (you may start a Mono project at any time, with the same code, and it will work properly).

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

You should set your own answer as the accepted answer to your question.
I've tried to do it, but StackOverflow does not allow me to do so, unless I wait one day more.
1

If the code that declares your enum ItemType is in another assembly (project) than either the code that declare the BaseItem class or the code that introduces the Ins1 and Ins2 variables, then it is vital that you recompile all assemblies when you make changes to the definition of the ItemType enum.

Improve this answer

2 Comments

They're in the same project, so this is not the issue :(
@BogdanMarginean You still need to stop your running/debugging process, compile again, and start from the beginning, when you make changes to your enum ItemType. Otherwise the source code could have different constants than the compiled IL code and that would lead to strange debugging behavior.
0

Just have an idea. Not sure if it will work. It seems the constructor of the BaseItem is being called after your initialization. Try to put a break point and see when the Constructor of BaseItem is being called. Or you could try to call the constructor of BaseItem explicitly before setting Name and Type.

Improve this answer

1 Comment

The main constructor gets called before the braces' one; also, if it helps, the base class has another field: IsConsumable, initialized to False in BaseItem, and re-initialized to True in the first instance; the enum value in the first instance is wrong, but IsConsumable has the right value, True.
0

This is just a guess, but, since the first value of an Enum is equivalent to 0, possibly the combination of setting a default value in the definition (ItemType.Misc, or 5) plus using a type initializer that sets the value back to what it would be if you didn't have a default value (ItemType.Food, or 0) is causing the default value you specified (ItemType.Misc) to be persisted.

Incidentally, and this is important, you don't actually have a constructor defined. The syntax 

Ins1 = new BaseItem
{
   Name = "Something",
   Type = ItemType.Food
};

... is not a call to a constructor, it is a call to a type initializer. Yes, the default constructor gets called, but nothing happens in that constructor.

I am betting that if you were to actually use a constructor and set the default value of ItemType there, you would see this problem go away. Something like:

public BaseItem()
{
    this.Type = ItemType.Misc;
}

While I don't recall reading anything explicitly making this point, I feel that you shouldn't set a default value for a public property or field using the syntax you used. If it needs to be set, set it in the constructor so that it can easily be overridden. The syntax you used is more suitable for private backing fields rather than things that can be set from outside the class.

Improve this answer

3 Comments

Adding the BaseItem() constructor didn't provide the expected results; it is strange, that only when setting the first value of the enum in the braces constructor, makes the instance revert to the value in BaseItem.
There's no problem in not giving a constructor explicitly. It is guaranteed that things happen in this order: (1) the field initializer sets the value to Misc. (2) the default constructor runs (does nothing in our case). (3) the assignment in the object initializer (new expression) runs an sets the value to Food. So it ends up being Food. It's defined by the specification.
I have done an update to my post; removing any kind of initialization inside of BaseItem worked.
0

This code should work fine. Maybe you should try posting a minimal program that reproduces your problem, because it has to be resulting from something else.

There is one thing you should be aware of. What you are using is not a constructor, it's an object initialization. The main difference is that when you use an object initializer, the resulting code first calls the default constructor on your object, and then sets properties/fields.

So this code:

var myItem = new BaseItem
{
    Name = "something",
    Type = ItemType.Misc
}

Is actually equivalent to this:

var myItem = new BaseItem();
myItem.Name = "something";
myItem.Type = ItemType.Misc;

What you probably want is to define a constructor, like this:

class BaseItem
{
    public BaseItem(string name, ItemType type)
    {
        this.Name = name;
        this.Type = type;
    }

    // ...
}

And then use it like this:

var myItem = new BaseItem("something", ItemType.Misc);

I would guess that using this more explicit approach might indirectly solve your bug, and would at least probably make your code less error-prone.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.