312 Part III Creating Components
code that calls a delegate might actually run a different method each time it executes. The best way to understand delegates is to see them in action, so let’s work through an example.
Note If you are familiar with C++, a delegate is similar to a function pointer. However, unlike function pointers, delegates are type-safe; you can make a delegate refer to only a method that matches the signature of the delegate, and you cannot call a delegate that does not refer to a valid method.
The Automated Factory Scenario
Suppose you are writing the control systems for an automated factory. The factory contains a large number of different machines, each performing distinct tasks in the production of the articles manufactured by the factory—shaping and folding metal sheets, welding sheets together, painting sheets, and so on. Each machine was built and installed by a specialist vendor. The machines are all computer-controlled, and each vendor has provided a set of APIs that you can use to control its machine. Your task is to integrate the different systems used by the machines into a single control program. One aspect on which you have decided to concentrate is to provide a means of shutting down all the machines, quickly if needed!
Note The term API stands for application programming interface. It is a method, or set of methods, exposed by a piece of software that you can use to control that software. You can think of the Microsoft .NET Framework as a set of APIs because it provides methods that you can use to control the .NET common language runtime and the Microsoft Windows operating system.
Each machine has its own unique computer-controlled process (and API) for shutting down safely. These are summarized here:
StopFolding(); |
// Folding and shaping machine |
FinishWelding(); |
// Welding machine |
PaintOff(); |
// Painting machine |
Implementing the Factory Without Using Delegates
A simple approach to implementing the shutdown functionality in the control program is as follows:
class Controller
{
// Fields representing the different machines private FoldingMachine folder;
private WeldingMachine welder; private PaintingMachine painter;
...
Chapter 17 Interrupting Program Flow and Handling Events |
313 |
public void ShutDown()
{
folder.StopFolding();
welder.FinishWelding();
painter.PaintOff();
}
...
}
Although this approach works, it is not very extensible or flexible. If the factory buys a new machine, you must modify this code; the Controller class and the machines are tightly
coupled.
Implementing the Factory by Using a Delegate
Although the names of each method are different, they all have the same “shape”: They take no parameters, and they do not return a value. (We consider what happens if this isn’t the case later, so bear with me!) The general format of each method is, therefore:
void methodName();
This is where a delegate is useful. A delegate that matches this shape can be used to refer to any of the machinery shutdown methods. You declare a delegate like this:
delegate void stopMachineryDelegate();
Note the following points:
Use the delegate keyword when declaring a delegate.
A delegate defines the shape of the methods it can refer to. You specify the return type (void in this example), a name for the delegate (stopMachineryDelegate), and any
parameters (there are none in this case).
After you have defined the delegate, you can create an instance and make it refer to a matching method by using the += compound assignment operator. You can do this in the constructor of the controller class like this:
class Controller
{
delegate void stopMachineryDelegate();
private stopMachineryDelegate stopMachinery; // an instance of the delegate
...
public Controller()
{
this.stopMachinery += folder.StopFolding;
}
...
}
Chapter 17 Interrupting Program Flow and Handling Events |
315 |
The current scheme adds the machine methods to the delegate in the Controller constructor. To make the Controller class totally independent of the various machines, you need to make stopMachineryDelegate type public and supply a means of enabling classes outside Controller
to add methods to the delegate. You have several options:
Make the delegate variable, stopMachinery, public:
public stopMachineryDelegate stopMachinery;
Keep the stopMachinery delegate variable private, but provide a read/write property to provide access to it:
public delegate void stopMachineryDelegate();
...
public stopMachineryDelegate StopMachinery
{
get
{
return this.stopMachinery;
}
set
{
this.stopMachinery = value;
}
}
Provide complete encapsulation by implementing separate Add and Remove methods.
The Add method takes a method as a parameter and adds it to the delegate, while the Remove method removes the specified method from the delegate (notice that you
specify a method as a parameter by using a delegate type):
public void Add(stopMachineryDelegate stopMethod)
{
this.stopMachinery += stopMethod;
}
public void Remove(stopMachineryDelegate stopMethod)
{
this.stopMachinery -= stopMethod;
}
If you are an object-oriented purist, you will probably opt for the Add/Remove approach. However, the others are viable alternatives that are frequently used, which is why they are shown here.
Whichever technique you choose, you should remove the code that adds the machine methods to the delegate from the Controller constructor. You can then instantiate a