The Automated Factory Scenario

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 their machine. Your task is to integrate
the different systems used by the machines into a single control program. One aspect that
you have decided to concentrate on is to provide a means of shutting all the machines
down, quickly if needed!
NOTE
The term API means Application Programming Interface. It is a method, or set of
methods, exposed by a piece of software allowing you to control that software. You can
think of the .NET Framework as a set of APIs, as it provides methods allowing you 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 below:
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
shown below:
class Controller
{
...
public void ShutDown()
{

folder.StopFolding();
welder.FinishWelding();
painter.PaintOff();
}
...
// Fields representing the different machines
private FoldingMachine folder;
private WeldingMachine welder;
private PaintingMachine painter;
}
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
However, 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 will 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), 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 += operator. You can do this in the constructor of the
controller class like this:
class Controller
{
delegate void stopMachineryDelegate();
...
public Controller()
{
this.stopMachinery += folder.StopFolding;
}
...
private stopMachineryDelegate stopMachinery; // Create an instance of the delegate
}
This syntax takes a bit of getting used to. You add the method to the delegate; you are not
actually calling the method at this point. The + operator is overloaded to have this new
meaning when used with delegates (we will talk more about operator overloading in
Chapter 19, “Operator Overloading”). Notice that you simply specify the method name,
and should not include any parentheses or parameters.
It is safe to use the += operator on an uninitialized delegate. It will be initialized
automatically. You can also use the new keyword to explicitly initialize a delegate with a
specific method, like this:
this.stopMachinery = new stopMachineryDelegate(folder.stopFolding);
You can call the method by invoking the delegate, like this:
public void ShutDown()
{
this.stopMachinery();
...
}
Invoking a delegate uses exactly the same syntax as making a method call. If the method
that the delegate refers to takes any parameters, you should specify them at this time.

NOTE
If you attempt to invoke a delegate that is uninitialized, you will get a
NullReferenceException.
The principal advantage of using a delegate is that it can refer to more than one method;
you simply use the += operator to add them to the delegate, like this:
public Controller()
{
this.stopMachinery += folder.StopFolding;
this.stopMachinery += welder.FinishWelding;
this.stopMachinery += painter.PaintOff;
}
Invoking this.stopMachinery() in the Shutdown method of the Controller class will
automatically call each of the methods in turn. The Shutdown method does not need to
know how many machines there are, or what the method names are. You can remove a
method from a delegate by using the –= operator:
this.stopMachinery += folder.StopFolding;
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 supply a means of allowing classes outside of 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. You also need to make the
stopMachineryDelegate type public as well:
•
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 which are frequently used, which is why we
have shown them.
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
Controller and objects representing the other machines like this (this example uses the
Add/Remove approach):
Controller control = new Controller();
FoldingMachine folder = new FoldingMachine();
WeldingMachine welder = new WeldingMachine();
PaintingMachine painter = new PaintingMachine();
...
control.Add(folder.StopFolding);

control.Add(welder.FinishWelding);
control.Add(painter.PaintOff);
...
control.ShutDown();
...