Do I need Delegates?

[Joel Finkel]

Folks,

I am confused as to how to implement the following solution.

I have a series of processing steps, each of which contains similar features
(forms, etc). Therefore, I create a base class, Step, and subclass from that
for specific steps. The Step class has a method, Execute(), which can return
either Success or Failure.

I have a Step Driver, which instantiates the first Step, calls its Execute()
method, and then, depending on the status, runs the approriate next Step.

How do I know what the approriate next step is? I could embed this in the
Step Driver by building some data structure that can be used to decide what
to do. But this is clumsy.

In fact, each Step should "know" what the next Step for Success is, and what
the next Step for Failure is. The Execute() method, instead of returning
Success or Failure, should simply return the approriate next Step.

My initial attempt resulted, not surprisingly, in immediately using up all
available memory. Futher attmpts resulted in compiler errors.

I need some assistance in implementing the following (pseudo) code. Thanks
in advance for all suggestions!

/Joel Finkel
fi****@sd-il.com

class Step : IDisposable {

string name;
Step SuccessStep; // do this is sucessful
Step NextStep; // handle failure

public Step {
}

public void ShowName() {
MessageBox.Show (name);
}

public Step Execute() {
return _execute();
}

public void Dispose() }
}

private Step _execute() {
// override for each sub class
}
}

class Step_1 : Step {

public Step_1 {
SuccessStep = Step_2; // do this is successful
FailureStep = Step_1a; // handle failure
}

private Step _execute() {
if (do some processing) {
return SuccessStep;
} else {
return FailureStep;
}
}
}

class Step_2 : Step {

public Step_2 {
SuccessStep = null; // this is the last step
FailureStep = Step_2a; // handle failure
}

private Step _execute() {
if (something) {
return SuccessStep;
} else {
return FailureStep;
}
}
}

class Step_Driver {

Step_Drvier() {
}

public void Main() {

Step nextStep;

Step thisStep = new Step_1();

// process steps until there ain't no more
while (thisStep != null) {
nextStep = thisStep.Execut e();
thisStep.Dispos e();
if (nextStep != null) {
thisStep = new nextStep();
}
}
}
}

[Kevin Spencer]

I don't know, Joel. Seems like you're working too hard here. I presume that
these "Steps" are executed one at a time, in a sequence, like the following:

1, 2, 3, 4, 5, 6, 7, 8

Am I correct? If so, doesn't that look an awful lot like an array or a
Collection, or a List?

--
HTH,

Kevin Spencer
Microsoft MVP
..Net Developer
A watched clock never boils.

"Joel Finkel" <Jo********@dis cussions.micros oft.com> wrote in message
news:05******** *************** ***********@mic rosoft.com...

Folks,

I am confused as to how to implement the following solution.

I have a series of processing steps, each of which contains similar
features
(forms, etc). Therefore, I create a base class, Step, and subclass from
that
for specific steps. The Step class has a method, Execute(), which can
return
either Success or Failure.

I have a Step Driver, which instantiates the first Step, calls its
Execute()
method, and then, depending on the status, runs the approriate next Step.

How do I know what the approriate next step is? I could embed this in the
Step Driver by building some data structure that can be used to decide
what
to do. But this is clumsy.

In fact, each Step should "know" what the next Step for Success is, and
what
the next Step for Failure is. The Execute() method, instead of returning
Success or Failure, should simply return the approriate next Step.

My initial attempt resulted, not surprisingly, in immediately using up all
available memory. Futher attmpts resulted in compiler errors.

I need some assistance in implementing the following (pseudo) code.
Thanks
in advance for all suggestions!

/Joel Finkel
fi****@sd-il.com

class Step : IDisposable {

string name;
Step SuccessStep; // do this is sucessful
Step NextStep; // handle failure

public Step {
}

public void ShowName() {
MessageBox.Show (name);
}

public Step Execute() {
return _execute();
}

public void Dispose() }
}

private Step _execute() {
// override for each sub class
}
}

class Step_1 : Step {

public Step_1 {
SuccessStep = Step_2; // do this is successful
FailureStep = Step_1a; // handle failure
}

private Step _execute() {
if (do some processing) {
return SuccessStep;
} else {
return FailureStep;
}
}
}

class Step_2 : Step {

public Step_2 {
SuccessStep = null; // this is the last step
FailureStep = Step_2a; // handle failure
}

private Step _execute() {
if (something) {
return SuccessStep;
} else {
return FailureStep;
}
}
}

class Step_Driver {

Step_Drvier() {
}

public void Main() {

Step nextStep;

Step thisStep = new Step_1();

// process steps until there ain't no more
while (thisStep != null) {
nextStep = thisStep.Execut e();
thisStep.Dispos e();
if (nextStep != null) {
thisStep = new nextStep();
}
}
}
}

[Daniel O'Connell [C# MVP]]

"Joel Finkel" <Jo********@dis cussions.micros oft.com> wrote in message
news:05******** *************** ***********@mic rosoft.com...

Folks,

I am confused as to how to implement the following solution.

I have a series of processing steps, each of which contains similar
features
(forms, etc). Therefore, I create a base class, Step, and subclass from
that
for specific steps. The Step class has a method, Execute(), which can
return
either Success or Failure.

I have a Step Driver, which instantiates the first Step, calls its
Execute()
method, and then, depending on the status, runs the approriate next Step.

How do I know what the approriate next step is? I could embed this in the
Step Driver by building some data structure that can be used to decide
what
to do. But this is clumsy.

In fact, each Step should "know" what the next Step for Success is, and
what
the next Step for Failure is. The Execute() method, instead of returning
Success or Failure, should simply return the approriate next Step.

My initial attempt resulted, not surprisingly, in immediately using up all
available memory. Futher attmpts resulted in compiler errors.

I need some assistance in implementing the following (pseudo) code.
Thanks
in advance for all suggestions!

I agree with Kevin that if this is a static sequence, you should just use an
array of the steps you need to take and iterate it. However, if this is a
more complicated scenario where multiple steps might be taken your on the
right track. However, your code will not compile as is, you are missing
parentheses on your constructors(pu blic Step_2() { ... }) and are
referencing type names instead of creating them (ie new Step_2();). Could
you build a short but complete example[1]?

1. http://www.yoda.arachsys.com/csharp/complete.html

[Joe [MCAD]]

> what the next Step for Success is, and what

the next Step for Failure is.
From his description it doesnt sound to me like a sequence of events, it
sounds more like a decision tree because we potentially would have different
next steps based on the current steps result. I agree with you that it would
be a poor design to have the next step(s) encapsulated within the step. Each
step should only contain the logic necessary to determine its truthality;
this will maximize steps reuseability.
The first big problem is that you are basing the steps method calls to a
class and not an interface, this will abstract yyour problem out and make it
more flexible to new classes.

public interface IStep
{
string Id;
bool Execute();
void Dispose();
}

next encapsulate the decision data, each step would need two of these, one
for true and one for false.
public strut Decision
{
bool Result;
string NextItemId;
}

I would say having an array of two items would be good; steps and the
relationships.

private Hashtable Relationships;
private NameValueCollec tion Steps;

Steps collection would contain ISteps.Id as the key and IStep as value. So
when you do a Steps["xyz"] you would get back an object of IStep with an Id
of xyz.

Relationships would have the keys of the current ID and would return a value
object Decision.

So how this works overall. After your relationships and steps are loaded
into the arrays. An example of how it would work: 'Step1' first to be
processed calls execute and returns true, iterates over the relationship
collection and acquires the NextItemId's for all decisions that are true. It
then takes these Id's and obtains the ISteps from the Steps collection,
calls execute method and the whole process starts over again. Actually the
process MUST be recursive.

You might also want to look up the Filter design pattern.

Joe
"Daniel O'Connell [C# MVP]" <[e-mail]> wrote in
message news:%2******** ********@tk2msf tngp13.phx.gbl. ..
"Joel Finkel" <Jo********@dis cussions.micros oft.com> wrote in message
news:05******** *************** ***********@mic rosoft.com...

Folks,

I am confused as to how to implement the following solution.

I have a series of processing steps, each of which contains similar
features
(forms, etc). Therefore, I create a base class, Step, and subclass from
that
for specific steps. The Step class has a method, Execute(), which can
return
either Success or Failure.

I have a Step Driver, which instantiates the first Step, calls its
Execute()
method, and then, depending on the status, runs the approriate next Step.

How do I know what the approriate next step is? I could embed this in
the
Step Driver by building some data structure that can be used to decide
what
to do. But this is clumsy.

In fact, each Step should "know" what the next Step for Success is, and
what
the next Step for Failure is. The Execute() method, instead of returning
Success or Failure, should simply return the approriate next Step.

My initial attempt resulted, not surprisingly, in immediately using up
all
available memory. Futher attmpts resulted in compiler errors.

I need some assistance in implementing the following (pseudo) code.
Thanks
in advance for all suggestions!

I agree with Kevin that if this is a static sequence, you should just use
an array of the steps you need to take and iterate it. However, if this is
a more complicated scenario where multiple steps might be taken your on
the right track. However, your code will not compile as is, you are
missing parentheses on your constructors(pu blic Step_2() { ... }) and are
referencing type names instead of creating them (ie new Step_2();). Could
you build a short but complete example[1]?

1. http://www.yoda.arachsys.com/csharp/complete.html

[Joel Finkel]

First of all, thanks for the responses!

Secondly, what I provided was pseudo code, simply to describe the solution I
was thinking about.

Thirdly, Joe, you are right, I need to make a decision as to which next step
to take based on the status of the previous step. It is always a binary
decision.

Since I posted this, I have thought that perhaps each step should actually
NOT encapsulate the decision. This informaiton should be a separate data
structure (object) that I can load from a configuration file.

I also came to the conclusion that a recursive solution is probably best.
My only concern is that the target is a Pocket PC, and I have to be extremely
mindful of memory usage.

Joe, I need to study the code you provide and think about it.

Once again, thanks so much for all your suggestions.

/Joel Finkel
fi****@sd-il.com

"Joe [MCAD]" wrote:

what the next Step for Success is, and what
the next Step for Failure is.

From his description it doesnt sound to me like a sequence of events, it
sounds more like a decision tree because we potentially would have different
next steps based on the current steps result. I agree with you that it would
be a poor design to have the next step(s) encapsulated within the step. Each
step should only contain the logic necessary to determine its truthality;
this will maximize steps reuseability.
The first big problem is that you are basing the steps method calls to a
class and not an interface, this will abstract yyour problem out and make it
more flexible to new classes.

public interface IStep
{
string Id;
bool Execute();
void Dispose();
}

next encapsulate the decision data, each step would need two of these, one
for true and one for false.
public strut Decision
{
bool Result;
string NextItemId;
}

I would say having an array of two items would be good; steps and the
relationships.

private Hashtable Relationships;
private NameValueCollec tion Steps;

Steps collection would contain ISteps.Id as the key and IStep as value. So
when you do a Steps["xyz"] you would get back an object of IStep with an Id
of xyz.

Relationships would have the keys of the current ID and would return a value
object Decision.

So how this works overall. After your relationships and steps are loaded
into the arrays. An example of how it would work: 'Step1' first to be
processed calls execute and returns true, iterates over the relationship
collection and acquires the NextItemId's for all decisions that are true. It
then takes these Id's and obtains the ISteps from the Steps collection,
calls execute method and the whole process starts over again. Actually the
process MUST be recursive.

You might also want to look up the Filter design pattern.

Joe
"Daniel O'Connell [C# MVP]" <[e-mail]> wrote in
message news:%2******** ********@tk2msf tngp13.phx.gbl. ..

"Joel Finkel" <Jo********@dis cussions.micros oft.com> wrote in message
news:05******** *************** ***********@mic rosoft.com...

Folks,

I am confused as to how to implement the following solution.

I have a series of processing steps, each of which contains similar
features
(forms, etc). Therefore, I create a base class, Step, and subclass from
that
for specific steps. The Step class has a method, Execute(), which can
return
either Success or Failure.

I have a Step Driver, which instantiates the first Step, calls its
Execute()
method, and then, depending on the status, runs the approriate next Step.

How do I know what the approriate next step is? I could embed this in
the
Step Driver by building some data structure that can be used to decide
what
to do. But this is clumsy.

In fact, each Step should "know" what the next Step for Success is, and
what
the next Step for Failure is. The Execute() method, instead of returning
Success or Failure, should simply return the approriate next Step.

My initial attempt resulted, not surprisingly, in immediately using up
all
available memory. Futher attmpts resulted in compiler errors.

I need some assistance in implementing the following (pseudo) code.
Thanks
in advance for all suggestions!

I agree with Kevin that if this is a static sequence, you should just use
an array of the steps you need to take and iterate it. However, if this is
a more complicated scenario where multiple steps might be taken your on
the right track. However, your code will not compile as is, you are
missing parentheses on your constructors(pu blic Step_2() { ... }) and are
referencing type names instead of creating them (ie new Step_2();). Could
you build a short but complete example[1]?

1. http://www.yoda.arachsys.com/csharp/complete.html

[Leslie Sanford]

"Joel Finkel" wrote:

First of all, thanks for the responses!

Secondly, what I provided was pseudo code, simply to describe the
solution I was thinking about.

Thirdly, Joe, you are right, I need to make a decision as to which
next step to take based on the status of the previous step. It is
always a binary decision.
A decision table might be helpful.

http://en.wikipedia.org/wiki/Decision_table
Since I posted this, I have thought that perhaps each step should
actually NOT encapsulate the decision. This informaiton should be a
separate data structure (object) that I can load from a configuration
file.

I also came to the conclusion that a recursive solution is probably
best. My only concern is that the target is a Pocket PC, and I have to
be extremely mindful of memory usage.

I've written a small decision table toolkit in C# (which I haven't
released yet to the public). It does indeed use recursion. It also uses
delegates, so your initial question is in line, at least, with the way I
solved this problem. This is the recursive function for making a
"decision":

private int Decide(object[] args, int actionIndex, int conditionIndex)
{
#region Guards

if(conditionInd ex >= conditions.Leng th)
{
return actionIndex;
}

#endregion

Condition c = conditions[conditionIndex];

if(c(args))
{
actionIndex |= 1 << conditionIndex;
}

return Decide(args, actionIndex, conditionIndex + 1);
}

Some explanation:

Decision tables are made up of four quadrants. The upper left corner
contains the rows of conditions. Here, conditions are represented by
delegates that return a boolean value. The 'conditions' variable is a
collection of condition delegates. The Decide function recursively calls
itself until it has reached the last condition.

Each condition is called and passed the 'args' variable, which could
represent anything. If the condition returns true, a flag is set into
the 'actionIndex'. When the Decide method finishes, the 'actionIndex'
will be used to determine which actions, also represented by delegates,
will be invoked. That part gets a little complicated, but not too much
so.

Anyway, if any of this sounds intriguing or useful, let me know, and I
can go into more detail.

[Joel Finkel]

Here is a solution that seems to work. The implementation of MyCollection is
not shown. Comments are appreciated. Thanks in advance.

/Joel Finkel
fi****@sd-il.com
public delegate bool myDelegate();

public class Step
{
public Step()
{
}

public bool Execute(myDeleg ate p_process)
{
// run the customized processing
return p_process();
}
}
public class StepProcess
/*
* This class contains customized code for all the steps we have defined.
* It also contains a standard form.
*/
{
// Most steps need access to a standard form
private StepForm _myForm;

public StepProcess()
{
// create an instance of the standard form
_myForm = new StepForm();
}

public void Dispose()
{
// cleanup
_myForm.Dispose ();
}

public bool Step1()
{
_myForm.Text = "Step 1";
return _myForm.ShowDia log() == DialogResult.Ye s;
}

public bool Step2()
{
_myForm.Text = "Step 2";
return _myForm.ShowDia log() == DialogResult.Ye s;
}

public bool Step3()
{
MessageBox.Show ("Hi, I am Step 3");
return true;
}
}
public class Decision
{
private string _successStep;
private string _failureStep;

public string successStep
{
get { return _successStep; }
}

public string failureStep
{
get { return _failureStep; }
}

public Decision(string p_successStep, string p_failureStep)
{
_successStep = p_successStep;
_failureStep = p_failureStep;
}
}
public class StepDriver
{
static void Main()
{
// create an instance of the object that has all the steps and the
standard form
StepProcess myStepProcess = new StepProcess();

/*
* TODO: this can probably be done through reflection
*/
// a bag of step procesees
MyCollection StepProcesses = new MyCollection();
StepProcesses.A dd("Step1", new myDelegate(mySt epProcess.Step1 ));
StepProcesses.A dd("Step2", new myDelegate(mySt epProcess.Step2 ));
StepProcesses.A dd("Step3", new myDelegate(mySt epProcess.Step3 ));

/*
* TODO: create this from a configuration file
*/
// a bag of decisions
MyCollection Decisions = new MyCollection();
Decisions.Add(" Step1", new Decision("Step2 ", "Step1"));
Decisions.Add(" Step2", new Decision("Step3 ", "Step1"));
Decisions.Add(" Step3", new Decision("", "Step1"));

// status of steps' execution
bool stat;

// use this to decide what the next step is
Decision thisDecision;

// use this to hold the proper function
myDelegate thisProcess;

// use this to execute the function
Step myStep = new Step();

// start with Step 1
string thisStep = "Step1";

while (thisStep != "")
{
// get this step's decision from the bag
thisDecision = (Decision) Decisions[thisStep];

// get the step's process from the bag
thisProcess = (myDelegate) StepProcesses[thisStep];

// ececute the process
stat = myStep.Execute( thisProcess);

// do the right thing
if (stat)
{
thisStep = thisDecision.su ccessStep;
}
else
{
thisStep = thisDecision.fa ilureStep;
}
}

// cleanup
myStepProcess.D ispose();

// tell the user we are done
MessageBox.Show ("Done");
}
}

[Joe [MCAD]]

I'm interested in the details. Please explain.

"Leslie Sanford" <ja**********@B iteMeHotmail.co m> wrote in message
news:wN******** ************@co mcast.com...

"Joel Finkel" wrote:

First of all, thanks for the responses!

Secondly, what I provided was pseudo code, simply to describe the
solution I was thinking about.

Thirdly, Joe, you are right, I need to make a decision as to which
next step to take based on the status of the previous step. It is
always a binary decision.

A decision table might be helpful.

http://en.wikipedia.org/wiki/Decision_table

Since I posted this, I have thought that perhaps each step should
actually NOT encapsulate the decision. This informaiton should be a
separate data structure (object) that I can load from a configuration
file.

I also came to the conclusion that a recursive solution is probably
best. My only concern is that the target is a Pocket PC, and I have to
be extremely mindful of memory usage.

I've written a small decision table toolkit in C# (which I haven't
released yet to the public). It does indeed use recursion. It also uses
delegates, so your initial question is in line, at least, with the way I
solved this problem. This is the recursive function for making a
"decision":

private int Decide(object[] args, int actionIndex, int conditionIndex)
{
#region Guards

if(conditionInd ex >= conditions.Leng th)
{
return actionIndex;
}

#endregion

Condition c = conditions[conditionIndex];

if(c(args))
{
actionIndex |= 1 << conditionIndex;
}

return Decide(args, actionIndex, conditionIndex + 1);
}

Some explanation:

Decision tables are made up of four quadrants. The upper left corner
contains the rows of conditions. Here, conditions are represented by
delegates that return a boolean value. The 'conditions' variable is a
collection of condition delegates. The Decide function recursively calls
itself until it has reached the last condition.

Each condition is called and passed the 'args' variable, which could
represent anything. If the condition returns true, a flag is set into
the 'actionIndex'. When the Decide method finishes, the 'actionIndex'
will be used to determine which actions, also represented by delegates,
will be invoked. That part gets a little complicated, but not too much
so.

Anyway, if any of this sounds intriguing or useful, let me know, and I
can go into more detail.

[Leslie Sanford]

"Joe [MCAD]" wrote:

I'm interested in the details. Please explain.

I wanted to write a small toolkit that implements decision tables:

http://en.wikipedia.org/wiki/Decision_table

I implemented the toolkit by writing a DecisionTable class that uses a
collection of delegates representing the conditions. In addition, it has
a collection of delegates representing the actions. The DecisionTable
has a Decide method. When the Decide method is called, the DecisionTable
recursively goes through its condition delegates, invoking each one.

If a condition returns true, a bitwise operation takes place setting a
bit in an index variable to 1. This bit is offset so that each bit in
the index variable represents the result of a specific condition. When
the Decide method finally finishes, it returns the index variable. It's
value is used to retrieve the actions to invoke from a collection. The
actions corresponds to the result of the conditions.

The toolkit is pretty basic right now. I need to spend some time with it
to polish it up.

[Joe [MCAD]]

You definitely got my attention. I have been working on
http://sourceforge.net/projects/sdsre because I needed (and still do) a way
to have rules in XML. On this current release I came to the conclusion that
execution of the rules shouldnt actually be contained in the rules
themselves, the associations between rules is becoming too complicated and
performance is slowing down on larger sets. From what I read so far I am
intereseted in implementing a decision table into SRE in its next rewrite,
mabey intergrate both of the projects. I had some questions i havent
understood yet, in a rule based system some rules are dependent on other
rules truthality, and some take priority over others. In SRE this has all
been internalized into the engine to make the rules simple (main goal of the
project). How would a decision table be optimized to evaluate only those
rules that could be executed in the current context. Another issue,
exaluating expressions are expensive and some rules are practally identical
to other rules except for maney an AND statement or two, would it be
possible to break down expressions into identical subexpressions and
evaluate only once. I would like to see your project

Joe
"Leslie Sanford" <ja**********@B iteMeHotmail.co m> wrote in message
news:l5******** *************** *******@comcast .com...

"Joe [MCAD]" wrote:

I'm interested in the details. Please explain.

I wanted to write a small toolkit that implements decision tables:

http://en.wikipedia.org/wiki/Decision_table

I implemented the toolkit by writing a DecisionTable class that uses a
collection of delegates representing the conditions. In addition, it has a
collection of delegates representing the actions. The DecisionTable has a
Decide method. When the Decide method is called, the DecisionTable
recursively goes through its condition delegates, invoking each one.

If a condition returns true, a bitwise operation takes place setting a bit
in an index variable to 1. This bit is offset so that each bit in the
index variable represents the result of a specific condition. When the
Decide method finally finishes, it returns the index variable. It's value
is used to retrieve the actions to invoke from a collection. The actions
corresponds to the result of the conditions.

The toolkit is pretty basic right now. I need to spend some time with it
to polish it up.