How to use a class's type as the type argument for an inherited collection property in C#

Question

I am trying to create a representation of various types of card that inherit from a generic card class and which all contain references to their owning decks.

I tried re-declaring them, as suggested here, but it still won't convert to the specific card type.

The code I currently have is as such:

public class Deck<T> : List<T> 
    where T : Card 
{
    void Shuffle()
    {
        throw new NotImplementedException("Shuffle not yet implemented.");
    }
}

public class Card
{
    public Deck<Card> OwningDeck { get; set; }
}

public class FooCard : Card
{
    public Deck<FooCard> OwningDeck
    {
        get
        {
            return (Deck<FooCard>)base.OwningDeck;
        }
        set
        {
            OwningDeck = value;
        }
    }
}

The compile-time error I am getting: Error 2 Cannot convert type Game.Cards.Deck<Game.Cards.Card> to Game.Cards.Deck<Game.Cards.FooCard>

And a warning suggesting I use a new operator to specify that the hiding is intentional. Would doing so be a violation of convention? Is there a better way?

My question to stackoverflow is this: Can what I am trying to do be done elegantly in the .NET type system? If so, can some examples be provided?

I'd make cards simple immutable objects without back reference. — CodesInChaos, Sep 23 '12 at 21:37
If that were possible, the derived class would violate the Liskov Substitution Principle, because any consumers of Card would expect a FooCard object to behave like one of type Card and thus OwningDeck to be of type Deck. Using "new" would not solve your problem, as then either Card.OwningDeck would be broken on that class, or OwningDeck would mean two different things depending on whether you look at the object as Card or FooCard (I'm not sure which would happen). — TeaDrivenDev, Sep 23 '12 at 21:42

score 3 · Answer 1 · answered Sep 23 '12 at 21:41

You could equip your cards with a generic parameter that specifies the base class of the cards you're using:

public class Card<TCard>
    where TCard : Card<TCard>
{
    public Deck<TCard> OwningDeck { get; set; }
}

Your FooCard class would then look like this:

public class FooCard : Card<FooCard>

An advantage over your current code could be that you don't have to redeclare the OwningDeck property; it's automatically of type Deck<FooCard> in FooCard.

score 2 · Answer 2 · answered Sep 23 '12 at 21:43

What you are hitting on here, is a common design mistake, that you are trying to specialize the property 'OwningDeck' to FooCard, which is 'hiding' the base declaration of 'OwningDeck'. The choice you have made, to put 'OwningDeck' in the Card class, is intended to ensure that all types of Card have an OwningDeck property - meaning also, that THAT property must be of a lowest-common-denominator Type (i.e. 'Deck').

As such, you can not redeclare this property in derived types (i.e. FooCard), because you are then attempting to CHANGE the type of the property - a bad design choice - and not actually supported in .net.

The reason you are getting a warning, is because, the property Deck<FooCard> OwningDeck HIDES the property Deck<Card> OwningDeck. If someone casts the variable to the type Card, then accessed the OwningDeck property, they will get the property from OwningDeck. If however, they cast it to FooCard then access the same property, they will get the value returned from Deck<FooCard> OwningDeck. The compiler doesnt know these may be accessing the same variable, but it is VERY risky, because a programmer will not expect this behavior from your code.

As far as a better implementation I see O.R. Mapper has beat me to the actual implementation. What he said ;)

StriplingWarrior · Answer 3 · 2012-09-23T21:59:23.470

You can achieve something close to what you're looking for if you are willing to make the Card class generic, like this:

public class Deck<T> : List<Card<T>> 
    where T : Card<T>
{
    void Shuffle()
    {
        throw new NotImplementedException("Shuffle not yet implemented.");
    }
}

public class Card<T> where T : Card<T>
{
    public Deck<T> OwningDeck { get; set; }
}

public class FooCard : Card<FooCard>
{
}

The reason the original code doesn't work is that a Deck<Card> is not the same as a Deck<FooCard>, nor vice versa. Imagine the following:

Deck<Card> deck = new Deck<Card>();
deck.Add(new BarCard());
Deck<FooCard> fooDeck = (Deck<FooCard>)deck;  // What should happen here?
FooCard foo = deck[0];                        // or here?

So you need to ask yourself, "Why does the Card class care which deck owns it?" In most programs I'm aware of, there is no reason for a card to be aware of that detail. If there is a specific reason you want it to know something about its Deck, how much does it really need to know about that Deck? For example, is it possible that a Deck could hold cards from a variety of different Deck types? When you get cards out of the deck, do you really need to know that they will be exactly the same type of card as your current card?

Once you have answered questions like these, you'll be more prepared to decide whether OwningDeck should be a Deck<T> or maybe some covariant or contravariant interface that Deck<T> implements, or whether it even belongs on the Card class at all.

Thank you for the insight. I really appreciate your code sample pointing out the reason why this does not compile. I will reassess my design choices and re-implement it. Thanks again for your input. — Edelweiss Peimann, Sep 23 '12 at 22:39

How to use a class's type as the type argument for an inherited collection property in C#

3 Answers3