Implementing command pattern and polymorphism

Question

I want to implement a command pattern. I have the following:

public class State
{
    public int Number { get; set; }

    public void Execute(IAction action)
    {
        if (action.IsValid(this))
            action.Apply(this);
    }            
}

public interface IAction
{
    bool IsValid(State state);
    void Apply(State state);
}       

public class ActionSet5IfZero : IAction
{

    public bool IsValid(State state)
    {
        if (state.Number == 0)
            return true;
        else
            return false;
    }

    public void Apply(State state)
    {
        state.Number = 5;
    }
}

And the program:

static void Main(string[] args)
{
    State s = new State();
    s.Execute(new ActionSet5IfZero());
}

That works as expected. My problem begins, when I would like to extend the State class:

public class ExtendedState : State
{
    public int Number2 { get; set; }
}

Now the action must apply changes on ExtendedState. So I thought I would create extended action that has two additional functions that take ExtendedState as a parameter:

public class ExtendedActionSet5IfZero : IAction
{

    public bool IsValid(State state)
    {
        throw new NotImplementedException();
    }

    public void Apply(State state)
    {
        throw new NotImplementedException();
    }

    public bool IsValid(ExtendedState state)
    {
        if (state.Number == 0 && state.Number2 == 0)
            return true;
        else
            return false;
    }

    public void Apply(ExtendedState state)
    {
        state.Number = 5;
        state.Number2 = 5;
    }
}

This is something I already do not like because the functions that implement the interface become redundant. Moreover I need to create a new Execute function in my ExtendedState that utilizes the new type and not IAction (otherwise not implemented functions get called).

I am sure it can be done in a nice OO way. Can you help me out? The aim is to create an extensible State class and IAction interface (maybe even generic, I do not know), so I can extend the State but remain the generic functionality without additional coding.

Olivier Jacot-Descombes · Accepted Answer · 2012-02-09 17:26:23Z

1

You could add a virtual SetNumber method to state

public class State 
{ 
    public int Number { get; set; } 

    public virtual void SetNumber(int n)
    { 
        Number = n;
    }

    public void Execute(IAction action) 
    { 
        if (action.IsValid(this)) 
            action.Apply(this); 
    }             
}

In the extended state you orverride it

public class ExtendedState : State  {
    public int Number2 { get; set; }

    public orverride void SetNumber(int n)
    { 
        base.SetNumber(n);
        Number2 = n;
    }
}

The action would then be implemented like this

public void Apply(State state)        
{
    state.SetNumber(5);        
}

EDIT:

What about declaring Number as array?

public class State  
{
    public int[] Numbers { get; private set; }

    public State()
    {
        Numbers = new int[1];
    }

   ...
}

The action then does this

public void Apply(State state)         
{
    for (int i = 0; i < state.Numbers.Length; i++) {
        state.Numbers[i] = 5;
    }
}

The constructor of ExtendedState would initialize Numbers with

Numbers = new int[2];

In addition, you could have properties for the single numbers

public int Number { 
    get { return Numbers[0]; }
    set { Numbers[0] = value; }
}

and

public int Number2 { 
    get { return Numbers[1]; }
    set { Numbers[1] = value; }
}

edited Feb 9, 2012 at 17:26

answered Feb 9, 2012 at 16:19

Olivier Jacot-Descombes

114k14 gold badges149 silver badges202 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Michal B. Over a year ago

hanks Olivier for the response. The problem is that I have ~infinite number of actions, therefore the command pattern. Your solution is not suitable in my case...Could I do something about virtualization of Execute command?

Teudimundo · Accepted Answer · 2012-02-09 16:09:50Z

0

You could use generics:

interface IAction<TState> where TState: State
{
    bool IsValid(TState state);
    void Apply(TState state);
}

answered Feb 9, 2012 at 16:09

Teudimundo

2,6901 gold badge21 silver badges28 bronze badges

1 Comment

Michal B. Over a year ago

I tried this one before. The problem is when I extend State class and try to reuse Execute function. IAction<State> type is unrelated to IAction<ExtendedState> and I get exception.

Chris Shain · Accepted Answer · 2012-02-09 16:25:17Z

How about adding StateContainer to State and Action:

public interface IStateContainer<TState, TAction> where TState : IState where TAction : IAction<TState> { 
    public TState State;
    public void Execute(TAction action);
}

public interface IState { }

public interface IAction<TState> where TState : IState {
    bool IsValid(TState state);
    void Apply(TState state);
}

Then your original classes can be replaced with:

public class ValidatingStateContainer<TState, TAction> : IStateContainer<TState, TAction> {

    public ValidatingStateContainer(TState state) {
        State = state;
    }

    public TState State { get; private set; }

    public void Execute(TAction action)
    {
        if (action.IsValid(this))
            action.Apply(State);
    }
}

public class ActionSet5IfZero : IAction<NumberState>
{
    public boolean IsValid(NumberState state)
    {
        if (state.Number == 0)
            return true;
        else
            return false;
    }

    public void Apply(NumberState state)
    {
        state.Number = 5;
    }
}

public class ExtendedActionSet5IfZero : ActionSet5IfZero, IAction<TwoNumberState>
{   
    public boolean IsValid(TwoNumberState state)
    {
        if (base.IsValid(state) && state.Number2 == 0)
            return true;
        else
            return false;
    }

    public void Apply(TwoNumberState state)
    {
        base.Apply(state);
        state.Number2 = 5;
    }
}

public class NumberState : IState {
    public int Number { get; set; }
}

public class TwoNumberState : NumberState {
    public int Number2 { get; set; }
}

Collectives™ on Stack Overflow

Implementing command pattern and polymorphism

3 Answers 3

1 Comment

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related