Constructor with an array of subclasses of an abstract class as a parameter

Answer 1

You'd likely find it easier to use params in the definition for the Slot constructor:

Slot(params Loot[] exclusiveLootTypes)

This would allow you to call it like:

new Slot(lootItem1, lootItem2, lootItem2 /*...etc*/);

Otherwise, you'd need to create an array and pass it in.

Answer 2

One approach would be to pass an array of Type objects to the Slot constructor:

public Slot(Type[] exclusiveLootTypes) {
    // be sure and check that each Type is a subtype of Loot!
}

// Construction looks like:
new Slot(new[] {GetType(AmmoContainer), GetType(GemContainer) /* or whatever */});

Then write a property setter for Content that checks the type of the assigned object, and signals some sort of error if that type isn't contained in ExclusiveLootTypes.

Answer 3

and to combine the previous suggestion to use params, you can use a LINQ extension to convert the params into a List in one step:

public Slot(params Type[] exclusiveLootTypes)
{
    this.Content = null;
    this.Count = 0;

    this.ExclusiveLootTypes = exclusiveLootTypes.ToList();
}

Answer 4

It sounds like your object design needs a slight adjustment.

What if the types of loot items were also interfaces, so for example, all ammo loot items inherit from IAmmoContainer.

Then you could pass in the IAmmoContainer type to restrict the slot.

public class Quiver : Container, IAmmoContainer
public class ShotPouch : Container, IAmmoContainer
// ...
new Slot(typeof(IAmmoContainer))

EDIT

Based on the discussion in the comments, here's how I'd go about designing this system.

The Loot class is fine. It represents the base of the loot hierarchy.

Then you define interfaces for the "slots" that an item can occupy. For example:

public class LongSword : Loot, IRightHandItem
public class ShortSword : Loot, IRightHandItem, ILeftHandItem

Then the PlayerInventory class has "slots" as properties, that are restricted to the appropriate type.

public class PlayerInventory
{
    public List<IRightHandItem> RightHandSlot { get; private set; }
    public List<ILeftHandItem> LeftHandSlot { get; private set; }
    // etc...
}