C# 4 and .NET 4

implementation inheritance ❘ 93
However, because your version of MyGroovyMethod() is not declared as new, the compiler picks up on the fact
that it’s hiding a base class method without being instructed to do so and will generate a warning (this applies
whether or not you declared MyGroovyMethod() as virtual). If you want, you can rename your version of
the method. This is the recommended course of action because it eliminates future confusion. However, if you
decide not to rename your method for whatever reason (for example, if you’ve published your software as a
library for other companies, so you can’t change the names of methods), all your existing client code will still
run correctly, picking up your version of MyGroovyMethod(). This is because any existing code that accesses
this method must be done through a reference to MyDerivedClass (or a further derived class).
Your existing code cannot access this method through a reference to HisBaseClass; it would generate
a compilation error when compiled against the earlier version of HisBaseClass. The problem can only
happen in client code you have yet to write. C# arranges things so that you get a warning that a potential
problem might occur in future code — you will need to pay attention to this warning and take care not to
attempt to call your version of MyGroovyMethod() through any reference to HisBaseClass in any future
code you add. However, all your existing code will still work fine. It may be a subtle point, but it’s quite an
impressive example of how C# is able to cope with different versions of classes.
Calling base Versions of functions
C# has a special syntax for calling base versions of a method from a derived class: base.().
For example, if you want a method in a derived class to return 90 percent of the value returned by the base
class method, you can use the following syntax:
class CustomerAccount
{
public virtual decimal CalculatePrice()
{
// implementation
return 0.0M;
}
}
class GoldAccount: CustomerAccount
{
public override decimal CalculatePrice()
{
return base.CalculatePrice() * 0.9M;
}
}
Note that you can use the base.() syntax to call any method in the base class — you don’t
have to call it from inside an override of the same method.
abstract Classes and functions
C# allows both classes and functions to be declared as abstract. An abstract class cannot be instantiated,
whereas an abstract function does not have an implementation, and must be overridden in any non-abstract
derived class. Obviously, an abstract function is automatically virtual (although you don’t need to supply the
virtual keyword; doing so results in a syntax error). If any class contains any abstract functions, that class
is also abstract and must be declared as such:
abstract class Building
{
public abstract decimal CalculateHeatingCost(); // abstract method
}
www.it-ebooks.info