You can create delegates for each operation and add them to an ordered collection, such as an array, in the order you'd like them to execute...

Odnośniki

Smutek to uczucie, jak gdyby się tonęło, jak gdyby grzebano cię w ziemi.
We have seen that chloramphenicol is a drug which can have dangerous side-effects and which should only be used for a narrow range of life-threatening diseases, most...
Every programming language enables some method for declaring local (or global) variables that can be used to store data...
get stuck, their musings may be overheard by someone else in the work area who can contribute...
WITH SUFFICIENT NOTICE THEY CAN BE MADE AVAILABLE IN DRUMSFROM LOS ANGELES...
Here, the constructors allocate the memory and initialize it, the operator= copies it, and the destructor frees the memory...
arithmetic operators accuracy of calculations 17-21 overloading 22-29 ActiveX using 17-26 entries for MATLAB 1-6 Array Editor...
such as views, procedures, and synonyms, can provide location transparency...
"Can you take her away?" I whispered to Mark...
Ja wykorzystywałem swój czas na droczenie się z inżynierami, technikami, elektrykami i cholernie głupim delegatem związku zawodowego, który obstawał przy tym,...
A po co Wookiem tajna turbowinda? S¹dzê, ¿e wszystkie biura delegatów by³y w nie wyposa¿one...

Smutek to uczucie, jak gdyby się tonęło, jak gdyby grzebano cię w ziemi.

Once all the delegates are created and added to the collection, you simply iterate over the array, invoking each delegated method in turn.
You begin by creating a class Image to represent the image that will be processed by the ImageProcessor:
public class Image
{
public Image( )
{
Console.WriteLine("An image created");
}
}
You can imagine that this stands in for a .gif or .jpeg file or other image.
The ImageProcessor then declares a delegate. You can of course define your delegate to return any type and take any parameters you like. For this example you'll define the delegate to encapsulate any method that returns void and takes no arguments:
public delegate void DoEffect( );
The ImageProcessor then declares a number of methods, each of which processes an image and each of which matches the return type and signature of the delegate:
public static void Blur( )
{
Console.WriteLine("Blurring image");
}

public static void Filter( )
{
Console.WriteLine("Filtering image");
}

public static void Sharpen( )
{
Console.WriteLine("Sharpening image");
}

public static void Rotate( )
{

page 241
Programming C#
Console.WriteLine("Rotating image");
}
In a production environment these methods would be very complicated, and
they'd actually do the work of blurring, filtering, sharpening, and rotating the image.

The ImageProcessor class needs an array to hold the delegates that the user picks, a variable to hold the running total of how many effects are in the array, and of course a variable for the image itself:
DoEffect[] arrayOfEffects;
Image image;
int numEffectsRegistered = 0;
The ImageProcessor also needs a method to add delegates to the array:
public void AddToEffects(DoEffect theEffect)
{
if (numEffectsRegistered >= 10)
{
throw new Exception("Too many members in array");
}
arrayOfEffects[numEffectsRegistered++] = theEffect;

}
It needs another method to actually call each method in turn:
public void ProcessImages( )
{
for (int i = 0;i < numEffectsRegistered;i++)
{
arrayOfEffects[i]( );
}
}
Finally, you need only declare the static delegates that the client can call, hooking them to the processing methods:
public DoEffect BlurEffect = new DoEffect(Blur);
public DoEffect SharpenEffect = new DoEffect(Sharpen);
public DoEffect FilterEffect = new DoEffect(Filter);
public DoEffect RotateEffect = new DoEffect(Rotate);
In a production environment in which you might have dozens of effects, you
might choose to make these properties rather than static methods. That would
save creating the effects unless they are needed at the cost of making the
program slightly more complicated.

The client code would normally have an interactive user-interface component, but we'll simulate that by choosing the effects, adding them to the array, and then calling ProcessImage, as shown in Example 12-2.
Example 12-2. Using an array of delegates
namespace Programming_CSharp
{

page 242
Programming C#
using System;

// the image which we'll manipulate
public class Image
{
public Image( )
{
Console.WriteLine("An image created");
}
}

public class ImageProcessor
{
// declare the delegate
public delegate void DoEffect( );

// create various static delegates tied to member methods
public DoEffect BlurEffect =
new DoEffect(Blur);
public DoEffect SharpenEffect =
new DoEffect(Sharpen);
public DoEffect FilterEffect =
new DoEffect(Filter);
public DoEffect RotateEffect =
new DoEffect(Rotate);

// the constructor initializes the image and the array
public ImageProcessor(Image image)
{
this.image = image;
arrayOfEffects = new DoEffect[10];
}

// in a production environment we'd use a more
// flexible collection.
public void AddToEffects(DoEffect theEffect)
{
if (numEffectsRegistered >= 10)
{
throw new Exception(
"Too many members in array");
}
arrayOfEffects[numEffectsRegistered++]
= theEffect;

}

// the image processing methods...
public static void Blur( )
{
Console.WriteLine("Blurring image");
}

public static void Filter( )
{
Console.WriteLine("Filtering image");
}

public static void Sharpen( )
{
Console.WriteLine("Sharpening image");
}

public static void Rotate( )

page 243
Programming C#
{
Console.WriteLine("Rotating image");
}

public void ProcessImages( )
{
for (int i = 0;i < numEffectsRegistered;i++)
{
arrayOfEffects[i]( );
}
}

// private member variables...
private DoEffect[] arrayOfEffects;
private Image image;
private int numEffectsRegistered = 0;

}

// test driver
public class Test
{
public static void Main( )
{
Image theImage = new Image( );

// no ui to keep things simple, just pick the
// methods to invoke, add them in the required
// order, and then call on the image processor to
// run them in the order added.
ImageProcessor theProc =
new ImageProcessor(theImage);
theProc.AddToEffects(theProc.BlurEffect);
theProc.AddToEffects(theProc.FilterEffect);
theProc.AddToEffects(theProc.RotateEffect);
theProc.AddToEffects(theProc.SharpenEffect);
theProc.ProcessImages( );
}
}
}

Output:

An image created
Blurring image
Filtering image
Rotating image
Sharpening image