Question

I have a method which uses a generic parameter and requires the downcasted form of the instance. For example,

public abstract class Animal {
}
public class Dog : Animal {
}
public class Cat : Animal {
}
public class AnimalHandler {
    public virtual void Pet<T>(T animal)
    {
    }
}

Given a collection of animals.

public List<Animal> Animals { get; set; }

How do I downcast individual animals before calling the Pet method?

I currently having working in this form.

if (animal is Dog) {
    _animalHandler.Pet((Dog)animal);
}
if (animal is Cat) {
    _animalHandler.Pet((Cat)animal);
}

Ideally, it would be something of this form.

var type = animal.GetType();
_animalHandler.Pet(animal.CastTo(type));

Clarification: I need the instance to be of the downcasted type before it is passed to the method. I need a Dog or Cat specifically to be passed in.

Answer 1

You can accomplish this using the new .NET 4 dynamic keyword:

namespace Rextester
{
    public class Program
    {
    public abstract class Animal {
    }
    public class Dog : Animal {
    }
    public class Cat : Animal {
    }
    public class AnimalHandler {
        public virtual void Pet<T>(T animal) {
            Console.WriteLine(typeof(T));
        }
    }

    public class Problem {
        public List<Animal> Animals { get; set; }
        private readonly AnimalHandler _animalHandler;

        public Problem(AnimalHandler animalHandler) {
            _animalHandler = animalHandler;
            Animals = new List<Animal> { new Cat(), new Dog() };
        }

        public void MakeDecision() {
            foreach (var animal in Animals) {
                 _animalHandler.Pet(animal);
            }
        }
    }

        public static void Main(string[] args)
        {
            List<Animal> animals = new List<Animal>();
            animals.Add(new Dog());
            animals.Add(new Cat());

            var handler = new AnimalHandler();
            handler.Pet((dynamic)animals[0]);
            handler.Pet((dynamic)animals[1]);
        }
    }
}

Notice the cast to dynamic in the calls to Pet. Though doing it this way negates the necessity of Pet being generic in the first place.