Принцип объектно-ориентированного программирования при написании калькулятора

public abstract class CalcBase
        {
            protected readonly List<string> Command;
 
            protected readonly Dictionary<string, double> _values = new Dictionary<string, double>(); 
 
            protected CalcBase(List<string> command)
            {
                Command = command;
            }
 
            public virtual bool IsValidParametr(string param, object value)
            {
                if (value != null)
                {
                    double v;
                    if (!_values.TryGetValue(param, out v))
                    {
                        if (double.TryParse(value.ToString(), out v))
                        {
                            _values.Add(param, v);
                            return true;
                        }
                    }
                }
                return false;
            }
 
            public abstract double Execute();
 
            public abstract string CommandDescription { get; }
 
            public abstract int CommandID { get; }
 
            public virtual List<string> GetParameters()
            {
                return Command;
            }
        }
 
        public class PlusAverage : Plus
        {
            public override string CommandDescription
            {
                get { return @"Среднее из суммы 2 чисел - 2"; }
            }
 
            public override int CommandID
            {
                get { return 2; }
            }
 
            public override double Execute()
            {
                var result = base.Execute();
                return result/2;
            }
        }
 
        public class Plus : CalcBase
        {
            public Plus()
                : base(new List<string> {"a", "b"})
            {
            }
 
            #region Overrides of CalcBase
 
            public override double Execute()
            {
                double result = 0;
                foreach (var c in Command)
                {
                    double v;
                    if (_values.TryGetValue(c, out v))
                    {
                        result += v;
                    }
                }
                return result;
            }
 
            public override string CommandDescription
            {
                get { return "Сложение двух чисел - 1"; }
            }
 
            public override int CommandID
            {
                get { return 1; }
            }
 
            #endregion
        }
 
        [STAThread]
        private static void Main(string[] args)
        {
            var calcBases = new List<CalcBase> {new Plus(), new PlusAverage()};
 
            while (true)
            {
                foreach (var calcBase in calcBases)
                {
                    Console.WriteLine(calcBase.CommandDescription);
                }
 
                CalcBase calc = null;
                int commandId = -1;
                while (commandId==-1)
                {
                    Console.Write("Введите параметр или нажмите x, чтобы выйти:");
                    var readLine = Console.ReadLine();
                    if (string.IsNullOrEmpty(readLine))
                        continue; 
                    if (int.TryParse(readLine, out commandId))
                    {
                        foreach (var calcBase in calcBases)
                        {
                            if(calcBase.CommandID == commandId)
                            {
                                calc = calcBase;
                                break;
                            }
                        }
                    }
                    if (readLine == "x") break;
                }
                
                if(calc==null)
                    break;
 
                foreach (var param in calc.GetParameters())
                {
                    while (true)
                    {
                        Console.Write(string.Format("Введите {0}: ", param));
                        if (calc.IsValidParametr(param, Console.ReadLine()))
                        {
                            break;
                        }
                    }
                }
                Console.WriteLine("Результат = " + calc.Execute().ToString());
            }
        }

internal class Program
    {
        [STAThread]
        private static void Main(string[] args)
        {
            var calcBases = new List<CalcBase> {new Plus()};
 
            while (true)
            {
                foreach (CalcBase calcBase in calcBases)
                {
                    Console.WriteLine(calcBase.CommandDescription);
                }
 
                CalcBase calc = null;
                int commandId = -1;
                while (commandId == -1)
                {
                    Console.Write("Введите параметр или нажмите x, чтобы выйти:");
                    string readLine = Console.ReadLine();
                    if (string.IsNullOrEmpty(readLine))
                        continue;
                    if (int.TryParse(readLine, out commandId))
                    {
                        foreach (CalcBase calcBase in calcBases)
                        {
                            if (calcBase.CommandID == commandId)
                            {
                                calc = calcBase;
                                break;
                            }
                        }
                    }
                    if (readLine == "x") break;
                }
 
                if (calc == null)
                    break;
 
                calc.Reset();
                foreach (string param in calc.GetParameters())
                {
                    while (true)
                    {
                        Console.Write(string.Format("Введите {0}: ", param));
                        if (calc.IsValidParametr(param, Console.ReadLine()))
                        {
                            break;
                        }
                    }
                }
                Console.WriteLine("Результат:");
                Dictionary<string, double?> dictionary = calc.Execute();
                foreach (string key in dictionary.Keys)
                {
                    Console.WriteLine(string.Format("{0} = {1}", key, dictionary[key]));
                }
            }
        }
 
        #region Nested type: CalcBase
 
        public abstract class CalcBase
        {
            protected readonly List<string> Command;
 
            protected readonly Dictionary<string, double> _values = new Dictionary<string, double>();
 
            protected CalcBase(List<string> command)
            {
                Command = command;
            }
 
            public bool IncludeHandmadeValue { get; set; }
 
            public abstract string CommandDescription { get; }
 
            public abstract int CommandID { get; }
 
            public virtual bool IsValidParametr(string param, object value)
            {
                if (value != null)
                {
                    double v;
                    if (!_values.TryGetValue(param, out v))
                    {
                        if (double.TryParse(value.ToString(), out v))
                        {
                            _values.Add(param, v);
                            return true;
                        }
                    }
                }
                return false;
            }
 
            public abstract Dictionary<string, double?> Execute();
 
            public virtual List<string> GetParameters()
            {
                return Command;
            }
 
            public void Reset()
            {
                _values.Clear();
            }
        }
 
        #endregion
 
        #region Nested type: Plus
 
        public class Plus : CalcBase
        {
            public Plus()
                : base(new List<string> {"a", "b", "c"})
            {
            }
 
            #region Overrides of CalcBase
 
            public override string CommandDescription
            {
                get { return "Решение квадратного уравнения - 1"; }
            }
 
            public override int CommandID
            {
                get { return 1; }
            }
 
            public override Dictionary<string, double?> Execute()
            {
                var result = new Dictionary<string, double?>();
                double a;
                double b;
                double c;
                if (_values.TryGetValue("a", out a) && _values.TryGetValue("b", out b) &&
                    _values.TryGetValue("c", out c))
                {
                    if (IncludeHandmadeValue)
                    {
                        result.Add("a", a);
                        result.Add("b", b);
                        result.Add("c", c);
                    }
                    double D = b*b - 4*a*c;
                    if (D > 0 || D == 0)
                    {
                        result.Add("D", D);
                        double x1 = (-b + Math.Sqrt(D))/(2*a);
                        result.Add("x1", x1);
                        double x2 = (-b - Math.Sqrt(D))/(2*a);
                        result.Add("x2", x2);
                    }
                    else
                    {
                        result.Add("Дискриминант d < 0 ---> Решение квадратного уравнения невозможно.", null);
                    }
                }
                return result;
            }
 
            #endregion
        }
 
        #endregion
    }