Using GetType / instanceof in C # Compared to Alternatives

Question

I ran into a problem in a game that I am doing in C #. This is a simple tile based game, and the problem occurred to me, I am trying to do:

Say we have the main types of tiles, circles and diamonds that are subclasses of Tile. Instead of just matching circles, I tried to extract the “match” behavior in the abstract Tile method: canMatchWith (Tile t). Tiles also have two methods for adding / removing tiles that they can compare with.

So let's say that we have a round tile in the middle of our game, and we have a powerup that says: "The circles on the circle can coincide with the square tiles in this turn." I would go through all the Circle tiles and say circleTile.addCanMatchWith (typeof (Square)). Inside, we have a canMatchWith list.

Then later I want to say: “Circles can no longer coincide with squares” and just say circleTile.removeCanMatchWith (typeOf (Square)).

This is my current solution, and it works fine without any performance flaws that I noticed (this is a tile based game, so these types are evaluated only once per “move”, not frame by frame). However, a voice in my head tells me that this is a bad way to carry out this behavior. Therefore, I have several alternatives:

• Enumerates ... Each Tile can consist of a variable of type Tiletype. This will be initialized in the constructor and set to Type.SQUARE for squares, etc. Then each Tile will have a canMatchWith list, and the functionality is the same as my original implementation. Except in this case, it is a little more complicated. Let's say I have some subclasses of circle, oval and elipse. I want the ovals to fit ONLY squares, but elipses can fit all circles, not squares.

The problem is redundancy, my enum now has OVAL and ELIPSE, and the Elipse class will have (CIRCLE, OVAL, ELIPSE TileTypes) as types that it can compare with. This is completely redundant, I just want to say “Circle”, which I could with the help of types. I believe that Tiles can have TileType baseType and TileType actualType.

2. Some form of behavior. Forget the Tile subclasses, just specify the Tiles methods and the instance variable for the List. Then at runtime we can just say someTile.addCanMatch (new CircleMatchBehavior ()). This seems silly, because I will have a bunch of classes just saying that you can fit in a certain form.

In general, what I'm trying to accomplish is that several types of objects can interact with any number of different types. The question is what should I use for Type. Can i use gettype here? Lists? Or is there a better strategy that someone would recommend? I try to be as general as possible, these tiles should not have any hard-coded dependencies on other fragments and should be able to change who they can interact with on the fly. Let's say I'm doing a new subclass of the subclass, the Pentagon ... well, Pentagons can match squares, circles, and Pentagons. Easy with my implementation, but something tells me it's dirty OOP practice.

It seems to me that I should use types / enumerations because I am not trying to say thisTile.addCanMatch (Tile someOtherObject). This is too specific, I want thisTile to be able to map to all fragments that are instances of a particular class.

Answer 1

If all forms of the same type will always share the behavior, then it makes sense not to keep this behavior at the “one instance” level. Instead, you can have a "CanMatchManager" that stores a dictionary of lists indexed by type of form. Then, when the circle tries to compare the match, it asks for types that it can match with MatchManager. In addition, MatchManager can take two pieces and determine if they match. This is the Mediator

Answer 2

I know that the question has already been answered and accepted, but once I did something similar, and I thought that I would just post the code here.

public class TypeMatchManager { private Dictionary<Type, List<Type>> savedMatches = new Dictionary<Type, List<Type>>(); public TypeMatchManager() { } public void AddMatch(Type firstType, Type secondType) { this.addToList(firstType, secondType); this.addToList(secondType, firstType); } public void DeleteMatch(Type firstType, Type secondType) { this.deleteFromList(firstType, secondType); this.deleteFromList(secondType, firstType); } public bool CanMatch(Type firstType, Type secondType) { List<Type> firstTypeList = this.findListForType(firstType); List<Type> secondTypeList = this.findListForType(secondType); return (firstTypeList.Contains(secondType) || secondTypeList.Contains(firstType)); } private void addToList(Type firstType, Type secondType) { var matchingTypes = this.findListForType(firstType); if (!matchingTypes.Contains(secondType)) { matchingTypes.Add(secondType); } } private void deleteFromList(Type firstType, Type secondType) { var matchingTypes = this.findListForType(firstType); if (matchingTypes.Contains(secondType)) { matchingTypes.Remove(secondType); } } private List<Type> findListForType(Type type) { foreach (var keyValuePair in savedMatches) { if (keyValuePair.Key == type) { return keyValuePair.Value; } } savedMatches.Add(type, new List<Type>()); return findListForType(type); } } 

The class was designed in such a way that it does not matter with which parameter you specify which type; it checks that type1.list is of type 2 and type2.list is of type.

A simple example:

  typeManager.AddMatch(a, b); Console.WriteLine(typeManager.CanMatch(a, b)); // True typeManager.DeleteMatch(b, a); Console.WriteLine(typeManager.CanMatch(a, b)); // False Console.WriteLine(typeManager.CanMatch(a, c)); // False typeManager.AddMatch(a, c); Console.WriteLine(typeManager.CanMatch(a, c)); // True Console.WriteLine(typeManager.CanMatch(a, d)); // False typeManager.AddMatch(b, d); Console.WriteLine(typeManager.CanMatch(a, d)); // False Console.WriteLine(typeManager.CanMatch(d, b)); // True typeManager.DeleteMatch(d, b); Console.WriteLine(typeManager.CanMatch(d, b)); // False Console.WriteLine(typeManager.CanMatch(b, d)); // False