Design approach for class objects with many common and some unique methods

Question

In the example below, we have two instances of the Terrier class, which derives from Dog.
One instance is referenced by a variable of type Terrier.
Using this variable, you have access to all members of the Terrier class.
On the other hand, the variable whose type is Dog can only reference members of the Dog class, even though the reference points to an instance of a Terrier.

Terrier bubba = new Terrier("Bubba", 2, "Happy");
bubba.Growl();    // Can call Terrier.Growl

Dog jack = new Terrier("Jack", 17, "Surly");
jack.Growl();     // ERROR: Can't call Growl method

I need to implement a class MyPets which has a List<Pets> which can hold either of Cat Object or a Dog Object.
Both these object have some common methods like MakeNoise() but some unique methods too which are not in base class like Cat has method ClimbTree().
This MyPets class will also have a method that will iterate through List<animals> and calls the MakeNoise() method and ClimbTree() method.

What should be the best approach to achieve this, using Abstract base class or some other method?

Answer 1

With regards to my comment, something along these lines should solve your issue:

public class Visitor
{
    public void doItterate(Cat c)
    {
        Console.WriteLine(c.ToString());
        c.makeNoise();
        c.climbTree();
    }

    public void doItterate(Dog d)
    {
        Console.WriteLine(d.ToString());
        d.makeNoise();
    }
}

public abstract class Pet
{
    public Pet(string name, int age, Mood mood)
    {
        this.MoodOfPet = mood;
        this.Name = name;
        this.Age = age;
    }

    public string Name
    {
        get;
        private set;
    }

    public int Age
    {
        get;
        private set;
    }

    public Mood MoodOfPet
    {
        get;
        private set;
    }

    public abstract void makeNoise();
    public override string ToString()
    {
        return this.Name + " is " + this.Age +
            " years old  and feels " + this.MoodOfPet;
    }

    public abstract void accept(Visitor v);
}

public enum Mood
{
    Surly,
    Happy
}

public abstract class Dog : Pet
{
    public Dog(string name, int age, Mood mood): base (name, age, mood)
    {
    }

    public override void makeNoise()
    {
        Console.WriteLine(this.Name + " is woofing");
    }

    public override void accept(Visitor v)
    {
        v.doItterate(this);
    }
}

public class SheepDog : Dog
{
    public SheepDog(string name, int age, Mood mood): base (name, age, mood)
    {
    }
}

public class Cat : Pet
{
    public Cat(string name, int age, Mood mood): base (name, age, mood)
    {
    }

    public void climbTree()
    {
        Console.WriteLine(this.Name + " is climbing");
    }

    public override void makeNoise()
    {
        Console.WriteLine(this.Name + " is meowing");
    }

    public override void accept(Visitor v)
    {
        v.doItterate(this);
    }
}

public class Terrier : Dog
{
    public Terrier(string name, int age, Mood mood): base (name, age, mood)
    {
    }

    public void growl()
    {
        Console.WriteLine(this.Name + " is growling");
    }

    public override void makeNoise()
    {
        growl();
    }
}

public class MyPets
{
    private Visitor visitor = new Visitor();
    public MyPets()
    {
        Pets = new List<Pet>();
    }

    public List<Pet> Pets
    {
        get;
        private set;
    }

    public void addPet(Pet p)
    {
        Pets.Add(p);
    }

    public void itterate()
    {
        foreach (Pet p in Pets)
        {
            p.accept(visitor);
        }
    }
}

Fiddle

It's standard OOP design using abstract methods that get overloaded in more concrete classes later on.

EDIT Now it's using the visitor pattern

Running the following code:

MyPets pets = new MyPets();
pets.addPet(new Cat("Bob", 2, Mood.Surly));
pets.addPet(new Terrier("Jack", 17, Mood.Surly));
pets.addPet(new SheepDog("Bubba", 2, Mood.Happy));
pets.itterate();

Produces these results:

Bob is 2 years old and feels Surly

Bob is meowing

Bob is climbing

Jack is 17 years old and feels Surly

Jack is growling

Bubba is 2 years old and feels Happy

Bubba is woofing

Answer 2

In this answer, I present an attribute based solution. In some aspects it might be easier to maintain than the solution proposed by @Draken, but in other aspects it is less useful.

The idea: annotate pet method with an attribute, in order to mark it as an ability. I kept the attribute very simple, its only a marker without any additional meta information.

The IteratePetAbilities() method is the key method to access the pet abilities. It uses reflection in order to find methods that are marked with the ability attribute and invokes them.

// Note: Target method is required to have an empty parameter list
[AttributeUsage(AttributeTargets.Method)]
public sealed class PetAbilityAttribute : Attribute
{
}


public class MyPets
{
    public MyPets()
    {
        Pets = new List<Pet>();
    }

    public ICollection<Pet> Pets { get; set; }

    // Discover PetAbilityAttribute methods on the concrete pet type and invoke them dynamically
    public void IteratePetAbilities()
    {
        foreach (var pet in Pets)
        {
            Console.WriteLine("Pet '" + pet.PetName + "' enters the stage");
            var abilities = pet.GetType().GetMethods().Where(x => x.GetCustomAttributes(typeof(PetAbilityAttribute), true).Any());
            foreach (var abilityMethod in abilities)
            {
                Console.Write("# {0,12}() # ", abilityMethod.Name);
                abilityMethod.Invoke(pet, new object[] { });
            }
            Console.WriteLine();
        }
    }
}


public abstract class Pet
{
    public string PetName { get; set; }

    [PetAbility]
    public abstract void MakeNoise();

    // Note: this is not marked as an ability here
    public abstract void GoSleep();
}


public class Dog : Pet
{
    [PetAbility] // no effect, since base already has this attribute
    public override void MakeNoise()
    {
        Console.WriteLine("Says woof");
    }

    // not marked as an ability
    public override void GoSleep()
    {
        Console.WriteLine("Goes to the dogs house and sleeps");
    }
}


public class Terrier : Dog
{
    [PetAbility]
    public void HuntACat()
    {
        Console.WriteLine("Starts running after a poor little cat");
    }


    [PetAbility] // Unlike a regular dog, the Terrier goes to sleep by ability :)
    public override void GoSleep()
    {
        base.GoSleep();
    }
}


public class Cat : Pet
{
    public override void MakeNoise()
    {
        Console.WriteLine("Says meow");
    }

    [PetAbility]
    public void ClimbTree()
    {
        Console.WriteLine("Climbs a tree and is to scared to return on its own");
    }

    [PetAbility] // makes GoSleep an ability only for cats, even though the method exists in base class
    public override void GoSleep()
    {
        Console.WriteLine("Refuses to sleep and starts sharpening its claws");
    }
}



class Program
{
    static void Main(string[] args)
    {
        var myPets = new MyPets();
        myPets.Pets.Add(new Cat() { PetName = "Super Cat" });
        myPets.Pets.Add(new Dog() { PetName = "Little Dog" });
        myPets.Pets.Add(new Terrier() { PetName = "Hunter" });

        myPets.IteratePetAbilities();
    }

}

Output

Pet 'Super Cat' enters the stage
#    MakeNoise() # Says meow
#    ClimbTree() # Climbs a tree and is to scared to return on its own
#      GoSleep() # Refuses to sleep and starts sharpening its claws

Pet 'Little Dog' enters the stage
#    MakeNoise() # Says woof

Pet 'Hunter' enters the stage
#     HuntACat() # Starts running after a poor little cat
#      GoSleep() # Goes to the dogs house and sleeps
#    MakeNoise() # Says woof

Pro

• It is easy to add new abilities in any Pet subclass, no matter how deep it is nested in the subclass hierarchy (single point of code change)

Con

• Uses reflection
  • Becomes more complex when validity must be enforced (For example, what if the attribute is applied to a method with input parameter?).
  • Some people say it's slower than compile time binding (I didn't measure myself, but I tend to believe them)
• Limited control (For example, if you want to output the pet abilities in a certain order, additional work is required)
  • This generally applies to any inter-dependency between multiple abilities

Edit

Side note:

If x.GetCustomAttributes(typeof(PetAbilityAttribute), false) (instead of true) is called in IteratePetAbilities(), then Cat.MakeNoise would not be discovered, because the override method is not marked with the attribute.

Answer 3

You can simply use is and/or as operators if the number of subclasses is relatively small.

List<Pet> pets = new List<Pet>
{
    new Cat("cat1", 1, "Happy"),
    new Cat("cat2", 2, "Happy"),
    new Dog("dog", 1, "Surly"),
    new Terrier("dog", 3, "Happy")
};

// in your Iterate() method
foreach (var pet in pets)
{
    // common methods here
    pet.MakeNoise();

    if (pet is Cat)
    {
        var animal = (Cat)pet;
        animal.ClimbTree();
    }
    else if (pet is Terrier)
    {
        var animal = (Terrier)pet;
        animal.Growl();
    }
}

Visitor pattern is worth using when data should be separated from operations which is not your case.

Attribute solution should be avoided because of reflection.