C# 4 and .NET 4

interfaces ❘ 101
For example, take IDisposable . If a class wants to declare publicly that it implements the Dispose()
method, it must implement IDisposable — which in C# terms means that the class derives from
IDisposable .
class SomeClass: IDisposable
{
// This class MUST contain an implementation of the
// IDisposable.Dispose() method, otherwise
// you get a compilation error.
public void Dispose()
{
// implementation of Dispose() method
}
// rest of class
}
In this example, if SomeClass derives from IDisposable but doesn ’ t contain a Dispose() implementation
with the exact same signature as defi ned in IDisposable , you get a compilation error because the class
would be breaking its agreed - on contract to implement IDisposable . Of course, there ’ s no problem for
the compiler about a class having a Dispose() method but not deriving from IDisposable . The problem,
then, would be that other code would have no way of recognizing that SomeClass has agreed to support the
IDisposable features.
IDisposable is a relatively simple interface because it defi nes only one method. Most
interfaces will contain more members.
defining and implementing interfaces
This section illustrates how to defi ne and use interfaces through developing a short program that follows the
interface inheritance paradigm. The example is based on bank accounts. Assume that you are writing code
that will ultimately allow computerized transfers between bank accounts. And assume for this example that
there are many companies that may implement bank accounts, but they have all mutually agreed that any
classes that represent bank accounts will implement an interface, IBankAccount , which exposes methods to
deposit or withdraw money, and a property to return the balance. It is this interface that will allow outside
code to recognize the various bank account classes implemented by different bank accounts. Although
the aim is to allow the bank accounts to talk to each other to allow transfers of funds between accounts,
we won ’ t introduce that feature just yet.
To keep things simple, you will keep all the code for the example in the same source fi le. Of course, if
something like the example were used in real life, you could surmise that the different bank account classes
would not only be compiled to different assemblies, but would also be hosted on different machines owned
by the different banks. That ’ s all much too complicated for our purposes here. However, to maintain some
attempt at realism, you will defi ne different namespaces for the different companies.
To begin, you need to defi ne the IBankAccount interface:
namespace Wrox.ProCSharp
{
public interface IBankAccount
{
void PayIn(decimal amount);
bool Withdraw(decimal amount);
decimal Balance
{
get;
}
}
}
www.it-ebooks.info