遍历基类和继承类的所有实例

Question

I have a base class named CollidableObject and a couple of inherited classes named Player , Enemy , InertObject , etc.

I am trying to find an easy way to iterate through all the instances of them, so I initially created a list of the type CollidableObject and put all the instances of the inherited classes in there.

The thing is that because of the nature of polymorphism, when I do the following

foreach (CollidableObject CollidableObject in collidableObjects)
{
  if (CollidableObject is Player)
  {
    CollidableObject.Draw(spriteBatch, testPlayerTexture); 
  }
  // Then the same prodedure for each type of CollidableObject. 
  // Might change to switch or something.                              
}

The draw method that it calls is the generic Draw method from the CollidbaleObject base, not the overridden/new one from the Player/Enemy/inertObject class.

How do I get around this. Is there a way to iterate through a collection of objects from the same tree but maintaining their inherited type?

Answer 1

Is there no way to iterate through a collection of objects from the same tree but maintaining their inherited type?

Absolutely, there is a way to do that. However, you need to set up your hierarchy in a proper way:

• The Draw method in the CollidableObject needs to be marked virtual
• The Draw method in the Player needs to be marked as an override .

This will ensure that the call from your post would be routed to the Player 's override of the method, not to the method of the base.

On a related note, when you see code that checks the dynamic type of an object with the is operator, as in if (CollidableObject is Player) , you should get strong suspicions that you are doing something incorrectly. For example, you may be missing a double dispatch .

If all you need to know is the proper texture for the type, you could put textures in a Dictionary<Type,Texture> textureForType , and pull the right one in your loop using the GetType() of the collidable object.

Answer 2

Have you tried:

foreach (CollidableObject CollidableObject in collidableObjects)
{
    if (CollidableObject is Player)
    {
        ((Player) CollidableObject).Draw(spriteBatch, testPlayerTexture); 
    }    
    //Then the same prodedure for each type of CollidableObject. Might change to switch or something.                              
}

Answer 3

I would have each class implement a Draw method that is specific to that class. They would all need the same signature.

Then your foreach doesn't care which class it actually is, and would look like this

foreach (CollidableObject CollidableObject in collidableObjects)
{
      CollidableObject.Draw(....);                                        
}

This would be the "Object Oriented" way of doing it.