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(); ...