C# 4 and .NET 4

104 ❘ ChaPTer 4 inheritAnce
The main point to notice about this code is the way that you have declared both your reference variables as
IBankAccount references. This means that they can point to any instance of any class that implements this
interface. However, it also means that you can call only methods that are part of this interface through these
references — if you want to call any methods implemented by a class that are not part of the interface, you
need to cast the reference to the appropriate type. In the example code, you were able to call ToString()
(not implemented by IBankAccount) without any explicit cast, purely because ToString() is a System.
Object method, so the C# compiler knows that it will be supported by any class (put differently, the cast
from any interface to System.Object is implicit). Chapter 7, “Operators and Casts,” covers the syntax for
how to perform casts.
Interface references can in all respects be treated as class references — but the power of an interface
reference is that it can refer to any class that implements that interface. For example, this allows you to form
arrays of interfaces, where each element of the array is a different class:
IBankAccount[] accounts = new IBankAccount[2];
accounts[0] = new SaverAccount();
accounts[1] = new GoldAccount();
Note, however, that we’d get a compiler error if we tried something like this:
accounts[1] = new SomeOtherClass();
This causes a compilation error similar to this:
// SomeOtherClass does NOT implement
// IBankAccount: WRONG!!
Cannot implicitly convert type 'Wrox.ProCSharp. SomeOtherClass' to
'Wrox.ProCSharp.IBankAccount'
derived interfaces
It’s possible for interfaces to inherit from each other in the same way that classes do. This concept
is illustrated by defining a new interface, ITransferBankAccount, which has the same features as
IBankAccount but also defines a method to transfer money directly to a different account:
namespace Wrox.ProCSharp
{
public interface ITransferBankAccount: IBankAccount
{
bool TransferTo(IBankAccount destination, decimal amount);
}
}
Because ITransferBankAccount is derived from IBankAccount, it gets all the members of IBankAccount
as well as its own. That means that any class that implements (derives from) ITransferBankAccount
must implement all the methods of IBankAccount, as well as the new TransferTo() method defined in
ITransferBankAccount. Failure to implement all these methods will result in a compilation error.
Note that the TransferTo() method uses an IBankAccount interface reference for the destination account.
This illustrates the usefulness of interfaces: When implementing and then invoking this method, you don’t
need to know anything about what type of object you are transferring money to — all you need to know is
that this object implements IBankAccount.
To illustrate ITransferBankAccount, assume that the Planetary Bank of Jupiter also offers a current
account. Most of the implementation of the CurrentAccount class is identical to the implementations of
SaverAccount and GoldAccount (again, this is just to keep this example simple — that won’t normally be
the case), so in the following code just the differences are highlighted:
public class CurrentAccount: ITransferBankAccount
{
private decimal balance;
public void PayIn(decimal amount)
{
balance += amount;
}
www.it-ebooks.info