C# 4 and .NET 4

implementation inheritance ❘ 97
So far, this code works fine. One way to mess up the progression through the hierarchy of constructors,
however, is to declare a constructor as private:
private GenericCustomer()
{
name = "";
}
If you try this, you’ll find you get an interesting compilation error, which could really throw you if you don’t
understand how construction down a hierarchy works:
'Wrox.ProCSharp.GenericCustomer.GenericCustomer()’ is inaccessible due to its protection level
The interesting thing is that the error occurs not in the GenericCustomer class, but in the derived class,
Nevermore60Customer. What’s happened is that the compiler has tried to generate a default constructor
for Nevermore60Customer but has not been able to because the default constructor is supposed to invoke
the no-parameter GenericCustomer constructor. By declaring that constructor as private, you’ve made
it inaccessible to the derived class. A similar error occurs if you supply a constructor to GenericCustomer,
which takes parameters, but at the same time you fail to supply a no-parameter constructor. In this case,
the compiler will not generate a default constructor for GenericCustomer, so when it tries to generate
the default constructors for any derived class, it will again find that it can’t because a no-parameter base
class constructor is not available. A workaround would be to add your own constructors to the derived
classes — even if you don’t actually need to do anything in these constructors — so that the compiler doesn’t
try to generate any default constructors for them.
Now that you have all the theoretical background you need, you’re ready to move on to an example of how
you can neatly add constructors to a hierarchy of classes. In the next section, you start adding constructors
that take parameters to the MortimerPhones example.
adding Constructors with Parameters to a Hierarchy
You’re going to start with a one-parameter constructor for GenericCustomer, which specifies that
customers can be instantiated only when they supply their names:
abstract class GenericCustomer
{
private string name;
public GenericCustomer(string name)
{
this.name = name;
}
So far, so good. However, as mentioned previously, this will cause a compilation error when the compiler
tries to create a default constructor for any derived classes because the default compiler-generated
constructors for Nevermore60Customer will try to call a no-parameter GenericCustomer constructor,
and GenericCustomer does not possess such a constructor. Therefore, you’ll need to supply your own
constructors to the derived classes to avoid a compilation error:
class Nevermore60Customer: GenericCustomer
{
private uint highCostMinutesUsed;
public Nevermore60Customer(string name)
: base(name)
{
}
Now instantiation of Nevermore60Customer objects can occur only when a string containing the
customer’s name is supplied, which is what you want anyway. The interesting thing is what the
Nevermore60Customer constructor does with this string. Remember that it can’t initialize the name field
itself because it has no access to private fields in its base class. Instead, it passes the name through to the
base class for the GenericCustomer constructor to handle. It does this by specifying that the base class
www.it-ebooks.info