In a normal inheritance scheme, you always assign to base class objects. You could assign to a derived class reference as "Choice 2" indicates, but you should only do that if you need to call a function that exists only in the derived class (and not the base).
Now, if you are needing to do that, you should be questioning your design anyways, since a users of derived classes should go through the interface which is defined by the base class.
In other words, if the class structure is set up appropriately:
public class BasePrintClass
{
public void PrintBaseClass()
{
}
public abstract void PrintDerivedClass(); //Why these are seperated only you know
}
public class DerivedPrintClass
{
public override void PrintDerivedClass()
{
}
}
Then you would just use the base class, and let polymorphism handle the derived class call:
BasePrintClass print = new DerivedPrintClass();
print.PrintBaseClass();
print.PrintDerivedClass();
Polymorphism is your friend, use it! The downcasts in "Choice 1" are valid, but not recommended, and not needed if you use the above approach. In "Choice 2" you are avoiding polymorphism entirely by assigning to a derived class reference. This is better than casting, but not necessary if you design it correctly!
To answer the question explicitly, programmers cast to the base class because they have to (need a derived-only function). ANY other time is a sure-fire sign of bad design (or just bad code from people that don't understand polymorphism). Needing a derived-only function is definitely a sign of a questionable design, so feel free to ask about it anyways!
Let me know if I can clarify anything.