In C#, when I have an interface and several concrete implementations, can I cast the interface to a concrete type or is concrete type cast to interface?
What are the rules in this case?
Both directions are allowed in Java and C#. Downcasting needs an explicit cast and may throw an Exception if the object is not of the correct type. Upcasting, however, needs no explicit cast and is always safe to do.
That is, assuming you have
public interface Animal and two implementations of this
Animal meowAnimal = new Cat(); // No cast required Animal barkAnimal = new Dog(); // No cast required Cat myCat = (Cat) meowAnimal; // Explicit cast needed Dog myDog = (Dog) barkAnimal; // Explicit cast needed Dog myPet = (Dog) meowAnimal; // Will compile but throws an Exception
and you'll want a
catch around the explicit casts. In C# you have the useful
Dog myDog = barkAnimal as Dog; Dog myPet = meowAnimal as Dog;
No exception will be thrown, and myDog will be nonNull and myPet will be null. Java does not have an equivalent keyword although you can always use
if (meowAnimal instanceof Dog) tests to keep type safety. (I would guess that the "
as" keyword generates bytecode that does the if, assigning null of the
is fails. But perhaps .NET has a bytecode instruction that does the equivalent of "