Is there an alternative to is/as when working with inheritance and collections?

Question

I have the following class hierarchy of type Item:

Item

• Weapon : Item

• Armor : Item

I use a generic linked list of type Item. I have inserted different kinds of items: Armor, Weapon, etc. I stuck to two item types in this example.

I have the following code:

// Create the map. The underneath data structure is: 
// Array2D<LinkedList<Item>> m_map;
// A generic 2d array contains a linked list of type cell at each cell.
// This makes it easy to drop and pick up items at a given player position.
Map map = new Map(10, 10);

// First, I store two items at position (0,0) on my map.
map.AddItem(0, 0, new Weapon(6));
map.AddItem(0, 0, new Armor(3));

// Now, this only retrieves weapons. 
var qItems = from w in map.GetItems(0, 0)
        where w is Weapon
        select w;

// Weapons are outputted
foreach (Weapon weapon in qItems)
    Console.WriteLine(weapon.m_damage);

This works fine, but when I'm interested in gathering all items (which will be often), I have to do this:

// All items are outputted
foreach (Item item in map.GetItems(0, 0))
{
    if (item is Weapon) 
        Console.WriteLine("Damage: {0}", (item as Weapon).m_damage); 
    else if (item is Armor)
        Console.WriteLine("AC: {0}", (item as Armor).m_ac);
} 

Is there a more efficient way of retrieving different item types than using is/as? I think this can lead to bugs because what if a developer adds a new item type but forgets to make a condition for it in the foreach block? As you can guess, the list can get extensive of different types (10 or so in this project).

Edit: This is not a duplicate question. I'm looking at all subclasses, while the possible duplicate message is focused on retrieving one subclass.

Answer 1

In oop we rely on virtual dispatch to do our bidding so I usually do not use is keyword to determine the type of the object. I believe if you have an inheritance similar to the following then you can do

// items are outputted
foreach (var item in qItems)
    Console.WriteLine(item.ShowStats());
}

Item inheritance:

public abstract class Item {

    public abstract string ShowStats();
}

Then armor will be

public class Armor : Item {
    private readonly double _armor;

    public Armor(double armor) {
        _armor = armor;
    }

    public override string ShowStats() {
        return $"Armor: {_armor}";
    }
}

And weapon will be

public class Weapon : Item {
    private readonly double _damage;

    public Weapon(double damage) {
        _damage = damage;
    }

    public override string ShowStats() {
        return $"Damage: {_damage}";
    }
}

Answer 2

The reason you can't really do this is because of the following reason:

While you could use an example like this to find all the classes that inherit Item, you can't really make this automated because each class needs to access a different variable.

Take for example, you code that you posted:

// All items are outputted
foreach (Item item in map.GetItems(0, 0))
{
    if (item is Weapon) 
        Console.WriteLine("Damage: {0}", (item as Weapon).m_damage); 
    else if (item is Armor)
        Console.WriteLine("AC: {0}", (item as Armor).m_ac);
} 

In this code, you access the item as Weapon field m_damage. This, however, changes with the next line, as instead of finding field m_damage, you look for m_ac inside of item as Armor. It simply can't be automated beyond actually defining which classes item can be a Type of.

One suggestion I can make is that you could create properties within the Item class which contain m_damage and m_ac, then just override them in your inherited classes. This will allow you to access these fields without needing to check their Type.

public class Item
{
    public virtual int m_damage { get; set; }
}

public class Weapon : Item
{
    public override int m_damage => 4;
}

Alternatively, a better solution, as @ragyaiddo pointed out is to create a method within the Item class called PrintInfo(), which is then override into the inherited classes, which will simply print out information about that Item.

public abstract class Item
{
    public abstract void PrintStats();
}

public class Weapon : Item
{
    public int Damage { get; set; }

    public override void PrintStats()
    {
        Console.WriteLine("Damage: {0}", Damage);
    }
}

Answer 3

The visitor pattern is often used in this kind of situation. But you will always have something that resolves the subclasses

Your alternative is to build Items in such a way as they know what to do

So you just do Console.WriteLine(item.Stats)

Stats could be a new class ItemStats that is flexible and could store many keyvalue pairs of stats

Answer 4

As I pointed out in the comment, you can define an abstract method in Item class and have the inheriting classes implement their specific implementation. I created a sample implementation here. This is a similar approach to @Emrah Süngü's solution.

You can take this further with the implementation of Template Method Pattern or Strategy Pattern, depending on your requirements. These patterns are applicable when you have more than one class that need to follow the same common workflow, but each of these classes has different internal implementations of the said workflow.

Answer 5

As answered here using linq...

foreach (Weapon item in map.GetItems(0, 0).OfType<Weapon>())
    Console.WriteLine("Damage: {0}", item.m_damage); 

foreach (Armor item in map.GetItems(0, 0).OfType<Armor>())
    Console.WriteLine("AC: {0}", item.m_ac);

Alternatively...

public class Item { }
public class Weapon : Item
{
    public int Damage { get; set; }

    public override string ToString()
    {
        return $"Damage: {Damage}";
    }
}

public class Armor : Item
{
    public int AC { get; set; }

    public override string ToString()
    {
        return $"AC: {AC}";
    }
}

foreach (Item item in map.GetItems(0, 0))
    Console.WriteLine(item.ToString());