C# 4 and .NET 4

92 ❘ ChaPTer 4 inheritAnce
}
{
}
return “This method is an override defined in MyDerivedClass.”;
This syntax for method overriding removes potential runtime bugs that can easily occur in C++, when a
method signature in a derived class unintentionally differs slightly from the base version, resulting in
the method failing to override the base version. In C#, this is picked up as a compile-time error because the
compiler would see a function marked as override but no base method for it to override.
Neither member fields nor static functions can be declared as virtual. The concept simply wouldn’t make
sense for any class member other than an instance function member.
hiding methods
If a method with the same signature is declared in both base and derived classes, but the methods are
not declared as virtual and override, respectively, then the derived class version is said to hide the base
class version.
In most cases, you would want to override methods rather than hide them. By hiding them you risk calling
the wrong method for a given class instance. However, as shown in the following example, C# syntax is
designed to ensure that the developer is warned at compile time about this potential problem, thus making
it safer to hide methods if that is your intention. This also has versioning benefits for developers of
class libraries.
Suppose that you have a class called HisBaseClass:
class HisBaseClass
{
// various members
}
At some point in the future, you write a derived class that adds some functionality to HisBaseClass. In
particular, you add a method called MyGroovyMethod(), which is not present in the base class:
class MyDerivedClass: HisBaseClass
{
public int MyGroovyMethod()
{
// some groovy implementation
return 0;
}
}
One year later, you decide to extend the functionality of the base class. By coincidence, you add a method
that is also called MyGroovyMethod() and that has the same name and signature as yours, but probably
doesn’t do the same thing. When you compile your code using the new version of the base class, you
have a potential clash because your program won’t know which method to call. It’s all perfectly legal
in C#, but because your MyGroovyMethod() is not intended to be related in any way to the base class
MyGroovyMethod(), the result is that running this code does not yield the result you want. Fortunately,
C# has been designed to cope very well with these types of conflicts.
In these situations, C# generates a compilation warning that reminds you to use the new keyword to declare
that you intend to hide a method, like this:
class MyDerivedClass: HisBaseClass
{
public new int MyGroovyMethod()
{
// some groovy implementation
return 0;
}
}
www.it-ebooks.info