C# in Depth

Type system characteristics47public Person Clone(){}[Implementation goes here]object ICloneable.Clone(){return Clone();}Calls noninterfacemethodImplementsinterface explicitlyAny code that calls Clone() on an expression that the compiler knows is of type Personwill call the top method; if the type of the expression is just ICloneable, it will call thebottom method. This works but is really ugly.The mirror image of this situation also occurs with parameters, where if you hadan interface or virtual method with a signature of, say void Process(string x), thenit would seem logical to be able to implement or override the method with a lessdemanding signature, such as void Process(object x). This is called parameter typecontravariance—and is just as unsupported as return type covariance, with the sameworkaround for interfaces and normal overloading for virtual methods. It’s not ashowstopper, but it’s irritating.Of course, C# 1 developers put up with all of these issues for a long time—and Javadevelopers had a similar situation for far longer. While compile-time type safety is agreat feature in general, I can’t remember seeing many bugs where people actually putthe wrong type of element in a collection. I can live with the workaround for the lackof covariance and contravariance. But there’s such a thing as elegance and makingyour code clearly express what you mean, preferably without needing explanatorycomments. We’ll see later that C# 2 isn’t flawless either, but it makes large improvements.As an aside, let’s briefly go into an area that isn’t improved upon in any way byC# 2 and is only tangentially touched on by C# 3—dynamic typing.2.2.3 When does C# 1’s type system get in the way?I like static typing. Most of the time, it does what I want without much fuss, and it stopsme from making silly mistakes. It also means the IDE has more information to help mewith features such as IntelliSense.Just occasionally, it’s a real pain. If I’ve got two types that already have a particularmethod signature, but the types have nothing else in common or don’t know aboutmy code at all, why can’t I “pretend” they implement an interface containing that signature?This feature is known as duck typing (and yet again, different people use theterm to mean slightly different things) in that if something walks like a duck andquacks like a duck, you might as well treat it like a duck.If I’m working with an API (usually through COM) that doesn’t have strongly typedmethods, why can’t I ask the compiler to just stop using static typing for a while? VisualBasic has this feature, which is controlled with Option Strict; likewise, implicit typingis turned on and off using Option Explicit. Both of these features have received badpress, partly due to poor choices for default values in the past. It’s also partly due toLicensed to Rhona Hadida