Quickduck

I had a situation today which I thought was prime for writing some extension methods: I wasn’t allowed to modify the original type, and I also couldn’t subclass it, either. Extension methods to the rescue!

One thing which made the situation slightly interesting though, was that the original type also had a whole bunch of derived types – and for each of them, I wanted to customise the relevant extension method! Well, that’s all well and good, but what I really wanted to know was: lets say I was operating on a collection of the base types (where each individual item was an instance of a derived type), which extension method would get invoked?

Only one way to find out – write some code! For simplicity, I used the base class Animal, and added two derived types: Dog and Elephant.

    public abstract class Animal
    {
        public string Name { get; set; }
        public bool HasBoyBits { get; set; }
        public abstract string Type { get; }
    }

    public class Dog : Animal
    {
        public string Breed { get; set; }

        public override string Type
        {
            get { return "Dog"; }
        }
    }

    public class Elephant : Animal
    {
        public bool HasTusks { get; set; }

        public override string Type
        {
            get { return "Elephant"; }
        }
    }

Now for the extension method: CanBreed. For the base type Animal, the rule was simple – the animals had to be of the same type, and of the opposite sex:

    public static class AnimalExtensions
    {
        public static bool CanBreedWith(this Animal animal, Animal other)
        {
            return animal.Type == other.Type
                && animal.HasBoyBits != other.HasBoyBits;
        }
    }

For dogs, we only want to breed with dogs that are already of the same pedigree; and for elephants, we only want to breed with other elephants that have the same tusk status (yes, it’s pretty ambiguous, but whatever):

    public static class DogExtensions
    {
        public static bool CanBreedWith(this Dog dog, Animal other)
        {
            return AnimalExtensions.CanBreedWith(dog, other)
                && ((Dog) other).Breed == dog.Breed;
        }
    }

    public static class ElephantExtensions
    {
        public static bool CanBreedWith(this Elephant elephant, Animal other)
        {
            return AnimalExtensions.CanBreedWith(elephant, other)
                && ((Elephant) other).HasTusks == elephant.HasTusks;
        }
    }

Finally, the test data: two lists of animals, separated by gender:

    var baxter = new Dog { Name = "Baxter", HasBoyBits = true, Breed = "Jack Russell" };
    var missy = new Dog { Name = "Missy", HasBoyBits = false, Breed = "Jack Russell" };
    var jazzy = new Dog { Name = "Jazzy", HasBoyBits = false, Breed = "Poodle" };

    List<Animal> boys = new List<Animal>
    {
        baxter,
        new Elephant { Name = "Lance", HasBoyBits = true, HasTusks = true }
    };

    List<Animal> girls = new List<Animal>
    {
        missy,
        jazzy,
        new Elephant { Name = "Renee", HasBoyBits = false, HasTusks = true },
        new Elephant { Name = "Hephalump", HasBoyBits = false, HasTusks = false }
    };

Now, what I had to test was if .NET would use the Runtime type of each animal to work out which extension method to invoke. I was pretty confident that both of these would pass:

    Assert.IsTrue(baxter.CanBreedWith(missy));
    Assert.IsFalse(baxter.CanBreedWith(jazzy));

And sure enough, the unit test succeeds with flying colours. However, to make things slightly trickier, what if we do this?

    foreach (var boy in boys)
    {
        foreach (var girl in girls)
        {
            bool canBreed = boy.CanBreedWith(girl);

            Console.WriteLine("{0} can{2} breed with {1}",
                boy.Name, girl.Name, canBreed ? String.Empty : "'t");
        }
    }

Unfortunately, here’s what the output looks like:

Baxter can breed with Missy
Baxter can breed with Jazzy
Baxter can’t breed with Renee
Baxter can’t breed with Hephalump
Lance can’t breed with Missy
Lance can’t breed with Jazzy
Lance can breed with Renee
Lance can breed with Hephalump

So we can see that the animals aren’t allowed to breed when they’re of differing types (hence AnimalExtensions.CanBreedWith is being invoked); however, each type of animal is allowed to breed with any other animal of the same type. No joy! (Well, joy for the animals I suppose…)

On retrospect, this is pretty much the behavior that I expected, but I was still disappointed to find out that I had been right. Worse still, once the sample code was up and running, I thought, “Hey, I should have used Rabbits instead of Elephants, and then always returned false in the CanBreed method, because that would have been funnier”. Ahh, hindsight, where were you before?

Oh well. Time for some refactoring!