Nick Gravelyn

This is a little mini-series I’ve wanted to do for a while. I wanted to go through some common misconceptions about the way things work in .NET in order to help people get through problems instead of working around them. I have a few parts planned, but we’ll see how many I can come up with.

So this first one is about garbage, the most overrated fear of a lot of game developers. The big misconception for this post is the idea that you can’t use an enum as the key in a Dictionary<TKey, TValue> without generating garbage each time you index in. This leads a lot of people to do ugly hacks like casting the enum to an int or short (possibly even with a subclass or wrapper to do it for them). This is ugly and hacky and ruins the type safety that generics bring because you have allowed the key to be any integer or any short.

Instead of this silly work around that leads to ugly code that is harder to write and annoying to read, just pass an IEqualityComparer<T> to the dictionary’s constructor, where T is the same type as the dictionary key (and yes, it will enforce this at compile time so you can’t pass any other kind of IEqualityComparer<T> in even if you wanted to).

So as an example, let’s say I want to store my own dictionary of GamePadStates so that way I can always grab them but only update from the gamepad’s themselves once per frame. The first thing we’ll do is just make up a static class to contain this functionality for us:

public static class InputManager
{
	public static readonly Dictionary<PlayerIndex, GamePadState> CurrentStates;

	static InputManager()
	{
		// instantiate the dictionary
		CurrentStates = new Dictionary<PlayerIndex, GamePadState>();

 		// add the empty values to ensure all keys are present
		CurrentStates.Add(PlayerIndex.One, new GamePadState());
		CurrentStates.Add(PlayerIndex.Two, new GamePadState());
		CurrentStates.Add(PlayerIndex.Three, new GamePadState());
		CurrentStates.Add(PlayerIndex.Four, new GamePadState());
	}

	public static void Poll()
	{
		CurrentStates[PlayerIndex.One] = GamePad.GetState(PlayerIndex.One);
		CurrentStates[PlayerIndex.Two] = GamePad.GetState(PlayerIndex.Two);
		CurrentStates[PlayerIndex.Three] = GamePad.GetState(PlayerIndex.Three);
		CurrentStates[PlayerIndex.Four] = GamePad.GetState(PlayerIndex.Four);
	}
}

It’s a simple class but suits the purpose. We have a dictionary of the states and a Poll method that takes care of polling the input. We would then set this up to Poll once per frame (at the start of our Update method) and then simply reference the CurrentStates dictionary everywhere else.

At this point, many people would start screaming “But those enums are going to cause garbage!!1!”. Sure, right now they definitely are. But we can fix that. Let’s make a new class real quick:

public class PlayerIndexEqualityComparer : IEqualityComparer<PlayerIndex>
{
	private static PlayerIndexEqualityComparer defaultInstance;
	public static PlayerIndexEqualityComparer Default
	{
		get
		{
			if (defaultInstance == null)
				defaultInstance = new PlayerIndexEqualityComparer();
			return defaultInstance;
		}
	}

	public bool Equals(PlayerIndex x, PlayerIndex y)
	{
		return x == y;
	}

	public int GetHashCode(PlayerIndex obj)
	{
 		return obj.GetHashCode();
	}
}

This is a pretty simple class that just implements IEqualityComparer<T> for the PlayerIndex type. The static stuff is just a little extra I tossed on so that we can just reuse the same object if you want to have lots of dictionaries or other types that use IEqualityComparer<T> for the PlayerIndex type.

Anyway, let’s go back to the InputManager and alter the instantiation of the dictionary to this:

CurrentStates = new Dictionary<PlayerIndex, GamePadState>(PlayerIndexEqualityComparer.Default);

And now we no longer have garbage.

That’s really all it takes. You can make an IEqualityComparer<T> for any enum you want to use as a key in a dictionary and never worry about boxing and garbage ever again. Just please stop casting enums to ints/shorts as keys. That’s ugly.

Edit: For a bit more clarification on why you get boxing to begin with and why this fixes it, please see my first comment below (comment #2).