design pattern problem

[timewaster]

This isn't really a C# problem, but more of a design pattern problem.
I have the following abstract class..

abstract class SeriesOperator
{
private int _precedence;

public abstract double eval(double lhs, double rhs);

public SeriesOperator(int precedence)
{
_precedence = precedence;
}


public static bool IsAnOperator(char x)
{
if ((x == '+') || (x == '-') || (x == '*') || (x == '/') || (x == '(') || (x == ')'))
return true;
else
return false;
}

public static SeriesOperator CreateOperator(char x)
{
SeriesOperator ret = null;
switch (x)
{
case '+':
{
ret = new Add();
break;
}
case '-':
{
ret = new Subtract();
break;
}
.
.
.

default:
break;
}
return ret;
}

and multiple subclasses
i.e.....

class Add : SeriesOperator
{
public Add():base(1)
{
}

public override double eval(double lhs, double rhs)
{
return lhs + rhs;
}
}

The problem is that everytime I need to create a new subclass, I would need to modify the abstract class's methods IsAnOperator and CreateOperator.

How can I rewrite this class so that evertime I create a new subclass I would not have to touch the abstract base class?

[petes1234]

Why don't you substitute your fixed list of operators:

if ((x == '+') || (x == '-') || (x == '*') || (x == '/') || (x == '(') || (x == ')'))

with something more flexible such as an ArrayList of chars?

Or better yet, use List<char> and then use the List<T>.Contains(T t) method to see if the char is an operator.

[petes1234]

or perhaps a list of your class: List<SeriesOperator> operators....

One other thing, please learn about code tags. They're easy to use and make your code readable:

    class SeriesOperator
    {
        private static List<char> operators = new List<char>();

        private int _precedence;

        public abstract double eval(double lhs, double rhs);

        public SeriesOperator(int precedence)
        {
            _precedence = precedence;
        }

        public static bool IsAnOperator(char x)
        {
            if (operators.Contains(x))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public static SeriesOperator CreateOperator(char x)
        {
            SeriesOperator ret = null;
            switch (x)
            {
                case '+':
                    {
                        ret = new Add(x);
                        break;
                    }
                case '-':
                    {
                        ret = new Subract(x);
                        break;
                    }
                default:
                    break;
            }
        }

[timewaster]

But then how would you initialize the list?

[TheCPUWizard]

I would create a Builder Class, that Initialized the List. This would have to be modified (something does), but it would be a distinct file, that only contained the initialization, and therefore edits could not corrupt the abstract class.

[Luthv]

you could also delegate IsOperator check to the implementation class so the base abstract class doesn't need any modification when new implementation is added, and the only list you have will be the list of implementations.

    abstract class SeriesOperator
    {
        private int _precedence;
        private static List<SeriesOperator> _registeredOperators = new List<SeriesOperator>();

        public abstract double eval(double lhs, double rhs);

        protected abstract bool IsOperator(char x);

        public SeriesOperator(int precedence)
        {
            _precedence = precedence;
        }

        public static void RegisterOperator(SeriesOperator operatorImpl)
        {
            _registeredOperators.Add(operatorImpl);
        }

        public static bool IsAnOperator(char x)
        {
            bool retval = false;
            foreach (SeriesOperator operatorImpl in _registeredOperators)
            {
                if (operatorImpl.IsOperator(x))
                {
                    retval = true;
                    break;
                }
            }
            return retval;
        }
    }