Can you shadow AND override at the same time in C#?

Question

Consider the following classes:

abstract class Cog {}
class BigCog: Cog {}
class SmallCog: Cog {}

abstract class Machine {}
class BigMachine: Machine {}
class SmallMachine: Machine {}

Now all the machines work with cogs, but BigMachine only works with BigCog and SmallMachine only works with SmallCog. I'd like to make this nicely typed, so that I could to this:

Machine machine;
BigMachine bigMachine;
SmallMachine smallMachine;

Cog cog;
BigCog bigCog;
SmallCog smallCog;

bigMachine.cog = bigCog; // OK
smallMachine.cog = smallCog; // OK

bigMachine.cog = smallCog; // Compiler error, type mismatch
smallMachine.cog = bigCog; // Compiler error, type mismatch

machine.cog = cog; // Runtime error if type mismatch
machine.cog = bigCog; // Runtime error if type mismatch
machine.cog = smallCog; // Runtime error if type mismatch

bigMachine.cog.BigCogMethod(); // OK, BigMachine.cog is of type BigCog
smallMachine.cog.SmallCogMethod(); // OK, SmallMachine.cog is of type SmallCog

The only way I can think of achieving this is if I can BOTH override AND shadow the cog property:

abstract class Machine
{
    public virtual Cog cog { get; set; }
}
class BigMachine
{
    public override Cog cog
    {
        get
        {
            return base.cog;
        }
        set
        {
            if ( value != null && !(value is BigCog) )
                throw new ArgumentException();
            base.cog = value;
        }
    }
    new public BigCog cog // Compiler error, member "cog" already declared
    {
        get { return (BigCog)base.cog; }
        set { base.cog = value; }
    }
}

Unfortunately the compiler complains that there already is a class member named cog, so I cannot both override it and shadow at the same time. Is there some other elegant pattern that can solve this dilemma? Note that I do need to act on abstract Machine type variables and do the machine.cog = cog; thing, so making a generic class like class BigMachine: Machine<BigCog> doesn't work.

Answer 1

How about:

abstract class Machine<T> where T:Cog
{
    public virtual T cog { get; set; }
}

class BigMachine : Machine<BigCog>
{

}

You can create generic base class with Constraint on type parameter. This way you will limit Type of cog property to only types that derives from Cog type.

Answer 2

If I understand you correct you want RunTime error when cog type does not match? How about using interface + Explicit implementation?

interface IMachine
{
    Cog cog { get; set; }
}

abstract class Machine : IMachine
{
    Cog IMachine.cog { get; set; }
}

class BigMachine : Machine, IMachine
{
    public BigCog cog { get; set; }

    Cog IMachine.cog
    {
        get { return cog; }
        set { cog = (BigCog) value; }
    }
}

class SmallMachine : Machine, IMachine
{
    public SmallCog cog { get; set; }
    Cog IMachine.cog
    {
        get { return cog; }
        set { cog = (SmallCog)value; }
    }
}

Than instead of Machine class use IMachine interface

List<IMachine> list = new List<IMachine>();
list.Add(new BigMachine{cog =  new BigCog()});
list.Add(new SmallMachine{ cog= new SmallCog()});
list[1].cog = new BigCog(); // runtime error. Can not convert BigCog to SmallCog

Answer 3

C# does not support return type variance which makes this whole situation a mess.

I'd take a step back and thoughtfully reconsider if having BigMachine return a BigCog typed Cog property is really worth it.

Let's consider the scenarios:

1. I have a Machine typed reference. Ok, I can't really leverage a strongly typed property to begin with, machine.Cog will return a Cog typed cog and thats all I can ask for.
2. I have a BigMachine typed reference. Ok, so now bigMachine returns a Cog typed cog but I know its really a BigCog. I can simply do a cast: bigCog = (BigCog)(bigMachine.Cog) if I really need to. Or better yet, simply implement strongly typed properties that belong exclusively to BigMachine: BigMachine.BigCog for instance.

Also worth noting, is that return type variance does not provide type safety at all. There'd always need to be a runtime type check to make sure no one adds a wrongly typed Cog via a Machine typed reference. This type of set up can always blow up at runtime, you can't statically make it safe (without generics).

So, all this mess really just saves you one cast in a very specific scenario (chances are most of your Machine references are going to be Machine typed to begin with).

There is a reason return type variance is not in the language, and its because, although convenient, its not really an awesome feature. You can live without it just fine. So if the type system is not helping at all, don't fight it, chances are you are overcomplicating things.

Answer 4

Oh, and another approach, which I think is even worse than the previous.

abstract class Machine
{
    public virtual Cog cog { get; set; }
}
abstract class BigMachineBase: Machine
{
    public override Cog cog
    {
        get { return base.cog; }
        set
        {
            if ( value != null && !(value is BigCog) )
                throw new ArgumentException();
            base.cog = value;
        }
    }
}

class BigMachine: BigMachineBase
{
    new public BigCog cog
    {
        get { return (BigCog)base.cog; }
        set { base.cog = cog; }
    }
}

Answer 5

This is what I have to offer (not perfect either, but I guess that's the way I would do it):

abstract class Cog { };
class BigCog : Cog { }
class SmallCog : Cog { }

abstract class Machine
{
    public Cog Cog
    {
        get { return GetCog(); }
        set { SetCog(value); }
    }
    protected abstract Cog GetCog();
    protected abstract void SetCog(Cog value);
}
abstract class TypedMachine<T> : Machine where T: Cog
{
    private T typeSafeCog;
    public new T Cog
    {
        get { return typeSafeCog; }
        set { typeSafeCog = value; }
    }
    protected override Cog GetCog()
    {
        return typeSafeCog;
    }
    protected override void SetCog(Cog value)
    {
        if (value is T)
            typeSafeCog = (T)value;
        else
            throw new Exception("type error!");
    }
}
class BigMachine : TypedMachine<BigCog> { }
class SmallMachine : TypedMachine<SmallCog> { }

class Program
{
    static void Main(string[] args)
    {
        var bigCog = new BigCog();
        var smallCog = new SmallCog();
        var bigMachine = new BigMachine();
        bigMachine.Cog = smallCog; // compile error
        bigMachine.Cog = bigCog; // ok
        Machine[] anyMachine = { new SmallMachine(), new BigMachine() };
        anyMachine[0].Cog = smallCog; // ok
        anyMachine[1].Cog = smallCog; // runtime exception
        anyMachine[1].Cog = bigCog; // ok
        Console.ReadKey();
    }
}

Answer 6

Hmm, here's one approach I came up with, although I'm not very happy about it, so I'll see if anything better comes up:

abstract class Machine
{
    protected virtual Cog _cog { get; set; }
    public Cog cog
    {
        get { return this._cog; }
        set { this._cog = value; }
    }
}

class BigMachine: Machine
{
    protected override Cog _cog
    {
        get { return base._cog; }
        set
        {
            if ( value != null && !(value is BigCog) )
                throw new ArgumentException();
            base._cog = value;
        }
    }
    new public BigCog cog
    {
        get { return (BigCog)base._cog; }
        set { base._cog = value; }
    }
}

Answer 7

Assuming you don't have to use inheritance this would be another approach:

public class BigMachine
{
    private readonly Machine _machine;

    public BigMachine(Machine machine)
    {
        _machine = machine;
    }

    public BigCog Cog
    {
        get { return (BigCog)_machine.cog; }
        set { _machine.cog = value; }
    }
}

Although I don;t like that cast there.