Архитектура консольного калькулятора

using System;
using System.Collections.Generic;
public class View {
  public static void Main() {
    CommandOrModel model = new CommandOrModel();
    Controller controller = new Controller(model);  
  }
}
class Controller{
    private char symbol;
    public char Symbol{get{return symbol;}set{symbol = value;}}
    private string num;
    private double result;
    CommandOrModel mod;
    List<char> commands = new List<char>();
    List<double> nums = new List<double>();
    public Controller(CommandOrModel model){
        model.operation += Summa;
        mod = model;
        while(true){
            char symbol = char.Parse(Console.ReadLine());
            switch(char.IsDigit(symbol)){
                case true :
                num += symbol; 
                break;
                case false :    
                if(result == 0) result = double.Parse(num);
                else nums.Add(double.Parse(num));
                num = string.Empty;
                if(symbol != '='){
                    commands.Add(symbol);
                }
                break;
            }
            if(symbol == '='){
                for(int i = 0; i < commands.Count; i++){
                    Symbol = commands[i];
                    model.operation.Invoke(nums[i]);
                }
                nums.Clear();
                commands.Clear();
                Console.WriteLine(result);
                result = 0;
            }
        }
    }
    public void Summa(double n){
        switch(symbol){
            case '/' :
            result /= n;
            break;
            case '*' :
            result *= n;
            break;
            case '-' :
            result -= n;
            break;
            case '+' :
            result += n;
            break;
        }
    }
}
class CommandOrModel{
    public delegate void Operation(double n);
    public Operation operation;
}

using System;
using System.Collections.Generic;
 
// 0 - целое число
// 1 - вещественное число, на самом деле все числа double
// 3 - +
// 4 - -
// 5 - *
// 6 - /
// 7 - % целочисленное деление
// 8 - \ остаток от деления
// 9 - ^ возведение в степень
// математическая функция:
// 10 - sin
// 11 - cos
// 12 - tan
// 13 - ctn
// 14 - ln
// 15 - lg
// 16 - sqrt
// 17 - Pi()
// 128 - : присвоить однобуквенной переменной значение (для будущего релиза...)
// 129 - пользовательская переменная (a-z) (для будущего релиза...)
// 252 - ? вывести значения задействованных пользовательских переменных (для будущего релиза...)
// 253 - (
// 254 - )
// 255 - null
 
namespace NoteCalcCon
{
    public class Calculate
    {
        public struct TypeSPN
        {
            public double numeric;
            public byte typerec;
            public int level;
        }
        //public static double[] MyValue = new double[32]; // Для своих переменных (a-z)(ещё не реализовано)
        private const int maxOpers = 32; // максимальное количество элементов
        private const string operstr = "+-*/()%\\^="; // математические односимвольные операторы
                                                      // Эти символы/строки для вывода исходной строки после парсинга для WinForm приложения
        public readonly static string[] opers = { "_", "_", "_", "+", "-", "*", "/", "%", "\\", "^", "sin", "cos", "tan", "ctn", "ln", "lg", "sqrt", "Pi" };
        private static int levelHead; // начало вложенного уровня (левая скобка)
        private static int levelTail; // конец вложенного уровня (правая скобка)
                                      // разобранная по функциональности строка
        private static List<TypeSPN> ALSPSN, BFSPSN;
        private static bool flagNoError;
 
        public static List<TypeSPN> Parsing(string inpstr)
        {
            List<TypeSPN> alspsn = new List<TypeSPN>();
            string[] spns = PrePars(inpstr);
            int lvl = 0;
            int i = 0;
            while (i < maxOpers && spns[i] != "")
            {
                TypeSPN SPNS = new TypeSPN
                {
                    numeric = 0,
                    level = lvl,
                    typerec = 255
                };
                if (IsDigsInt(spns[i]))
                {
                    SPNS.numeric = double.Parse(spns[i]);
                    SPNS.typerec = 0;
                }
                else if (IsDigsDouble(spns[i]))
                {
                    SPNS.numeric = double.Parse(spns[i]);
                    SPNS.typerec = 1;
                }
                else if (spns[i].Length == 1)
                {
                    switch (spns[i])
                    {
                        case "+":
                            SPNS.typerec = 3;
                            break;
                        case "-":
                            SPNS.typerec = 4;
                            break;
                        case "*":
                            SPNS.typerec = 5;
                            break;
                        case "/":
                            SPNS.typerec = 6;
                            break;
                        case "%":
                            SPNS.typerec = 7;
                            break;
                        case "\\":
                            SPNS.typerec = 8;
                            break;
                        case "^":
                            SPNS.typerec = 9;
                            break;
                        case "(":
                            SPNS.typerec = 253;
                            lvl++;
                            SPNS.level = lvl;
                            break;
                        case ")":
                            SPNS.typerec = 254;
                            lvl--;
                            break;
                        default:
                            SPNS.typerec = 255;
                            flagNoError = false;
                            break;
                    }
                }
                else
                {
                    switch (spns[i])
                    {
                        case "sin":
                            SPNS.typerec = 10;
                            break;
                        case "cos":
                            SPNS.typerec = 11;
                            break;
                        case "tan":
                            SPNS.typerec = 12;
                            break;
                        case "ctn":
                            SPNS.typerec = 13;
                            break;
                        case "ln":
                            SPNS.typerec = 14;
                            break;
                        case "lg":
                            SPNS.typerec = 15;
                            break;
                        case "sqrt":
                            SPNS.typerec = 16;
                            break;
                        case "pi":
                            SPNS.typerec = 17;
                            break;
                        default:
                            SPNS.typerec = 255;
                            flagNoError = false;
                            break;
                    }
                }
                if (SPNS.typerec != 255)
                {
                    alspsn.Add(SPNS);
                }
                i++;
            }
            return alspsn;
        }
        public static bool Solve(string inpstr, out double otvet)
        {
            ALSPSN = Parsing(inpstr);
            BFSPSN = new List<TypeSPN>();
            // Скопируем весь массив элементов для вывода исходного выражения.
            for (int i = 0; i < ALSPSN.Count; i++)
            {
                BFSPSN.Add(ALSPSN[i]);
            }
            if (flagNoError)
            {
                int level = 999; // Уровень вложенности скобок.
                while (level > 0)
                {
                    levelHead = 0;
                    levelTail = ALSPSN.Count - 1;
                    bool flgTail = false;
                    level = 0;
                    // Находим самый верхний уровень вложенности и запоминаем позиции открывающей и закрывающей скобок.
                    for (int i = 0; i < ALSPSN.Count; i++)
                    {
                        if (ALSPSN[i].level > level)
                        {
                            level = ALSPSN[i].level;
                            levelHead = i;
                            flgTail = true;
                        }
                        if ((ALSPSN[i].level < level) && flgTail)
                        {
                            levelTail = i - 1;
                            flgTail = false;
                        }
                    }
                    if (level > 0)
                    {
                        TypeSPN tms = CalcLevel(levelHead, levelTail, ALSPSN); // Расчитаем выражение внутри скобок
                        tms.level = level - 1; // Понизим уровень вложенности
                        tms.typerec = 1;
                        ALSPSN[levelTail] = tms; // Ответ записали на место хвоста
                        for (int i = levelHead; i < levelTail; i++)
                        {
                            ALSPSN.RemoveAt(levelHead); // Всё остальное от головы до хвоста удаляем.
                        }
                    }
                    else
                    {
                        // А вот здесь всё выражение не имеет скобок и голова должна указывать на первый элемент, а хвост на последний
                        // Надо как-то проверить :(
                        TypeSPN tms = CalcLevel(levelHead, levelTail, ALSPSN);
                        ALSPSN[levelTail] = tms;
                        for (int i = levelHead; i < levelTail; i++)
                        {
                            ALSPSN.RemoveAt(levelHead);
                        }
                    }
                }
                otvet = ALSPSN[0].numeric;
                return true;
            }
            else
            {
                otvet = 0;
                return false;
            }
        }
        private static string[] PrePars(string inpstr)
        {
            // Разбираем полученную строку на числа и операторы/функции. Пока только в строковых словах
            string[] tmst = new string[maxOpers];
            flagNoError = true;
            for (int i = 0; i < maxOpers; i++)
            {
                tmst[i] = "";
            }
            char predchar = ' ';
            int curpos = 0;
            int curoper = 0;
            while (curpos < inpstr.Length)
            {
                char curchar = inpstr[curpos];
                if (curchar != ' ' && operstr.IndexOf(curchar) < 0)
                {
                    // Если не пробел и не математический оператор, то либо число, либо имя функции
                    tmst[curoper] += char.ToLower(curchar);
                    predchar = curchar;
                }
                else if (operstr.IndexOf(curchar) >= 0)
                {
                    // Если математический оператор, смотрим, не пустое-ли текущее слово. Иначе будет следующее слово
                    if (tmst[curoper] != "")
                    {
                        curoper++;
                    }
                    if (curpos == 0 && curchar == '-')
                    {
                        tmst[0] = "-";
                    }
                    else if (curpos > 1 && curchar == '-' && operstr.IndexOf(predchar) >= 0)
                    {
                        tmst[curoper] = "-";
                        predchar = '-';
                    }
                    else if (curpos > 1 && curchar == '-' && operstr.IndexOf(predchar) < 0)
                    {
                        tmst[curoper] = "-";
                        curoper++;
                    }
                    else
                    {
                        tmst[curoper] = curchar.ToString();
                        predchar = curchar;
                        curoper++;
                    }
                }
                else
                {
                    // Сюда попадаем в случае пробела. Просто переходим на новое слово
                    if (tmst[curoper] != "")
                    {
                        curoper++;
                    }
                }
                curpos++;
            }
            return tmst;
        }
        private static bool IsDigsDouble(string instr)
        {
            bool flag = double.TryParse(instr, out _);
            return flag;
        }
        private static bool IsDigsInt(string instr)
        {
            bool flag = int.TryParse(instr, out _);
            return flag;
        }
        private static TypeSPN CalcLevel(int Head, int Tail, List<TypeSPN> spsn)
        {
            // Расчёт полученного уровня вложенности.
            // Голова указывает на открывающую скобку, хвост - на закрывающую.
            double nn1 = 0, nn2 = 0;
            List<TypeSPN> mySPNs = new List<TypeSPN>();
            for (int i = Head; i <= Tail; i++)
            {
                if (spsn[i].typerec < 250)
                {
                    mySPNs.Add(spsn[i]);
                }
            }
            try
            {
                while (mySPNs.Count > 1)
                {
                    byte maxOper = 0;
                    int posOper = 0;
 
                    for (int i = 0; i < mySPNs.Count; i++)
                    {
                        if (maxOper < mySPNs[i].typerec)
                        {
                            maxOper = mySPNs[i].typerec;
                            posOper = i;
                        }
                    }
                    if (maxOper < 10 && maxOper > 1)
                    {
                        if (mySPNs[posOper - 1].typerec < 3)
                        {
                            nn1 = mySPNs[posOper - 1].numeric;
                        }
                        if (mySPNs[posOper + 1].typerec < 3)
                        {
                            nn2 = mySPNs[posOper + 1].numeric;
                        }
                        TypeSPN tms = new TypeSPN()
                        {
                            numeric = Calcul(nn1, maxOper, nn2),
                            typerec = 1,
                            level = mySPNs[posOper].level
                        };
                        mySPNs[posOper] = tms;
                        mySPNs.RemoveAt(posOper + 1);
                        mySPNs.RemoveAt(posOper - 1);
                    }
                    else if (maxOper >= 10 && maxOper < 17)
                    {
                        if (mySPNs[posOper + 1].typerec < 3)
                        {
                            nn1 = mySPNs[posOper + 1].numeric;
                        }
                        TypeSPN tms = new TypeSPN()
                        {
                            numeric = Calcul(nn1, maxOper, nn2),
                            typerec = 1,
                            level = mySPNs[posOper].level
                        };
                        mySPNs[posOper] = tms;
                        mySPNs.RemoveAt(posOper + 1);
                    }
                    else
                    {
                        TypeSPN tms = new TypeSPN()
                        {
                            numeric = Calcul(nn1, maxOper, nn2),
                            typerec = 1,
                            level = mySPNs[posOper].level
                        };
                        mySPNs[posOper] = tms;
                    }
                }
            }
            catch (Exception err)
            {
                //_ = MessageBox.Show($"Какая-то ошибка - {err}", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
                Console.WriteLine($"Какая-то ошибка - {err}");
            }
            TypeSPN res = new TypeSPN
            {
                numeric = 0,
                typerec = 0,
                level = 0
            };
            if (mySPNs.Count != 0)
            {
                res = mySPNs[0];
            }
            else
            {
                flagNoError = false;
            }
 
            return res;
        }
        private static double Calcul(double num1, byte oper, double num2)
        {
            double result = 0d;
            switch (oper)
            {
                case 3:
                    result = num1 + num2;
                    break;
                case 4:
                    result = num1 - num2;
                    break;
                case 5:
                    result = num1 * num2;
                    break;
                case 6:
                    try
                    {
                        if (num2 != 0)
                        {
                            result = num1 / num2;
                        }
                        else
                        {
                            flagNoError = false;
                        }
                    }
                    catch (Exception err)
                    {
                        //_ = MessageBox.Show($"Деление на ноль!\n{err}", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        Console.WriteLine($"Деление на ноль! - {err}");
                        flagNoError = false;
                    }
                    break;
                case 7:
                    if (num2 != 0)
                    {
                        while (num1 > num2)
                        {
                            num1 -= num2;
                            result += 1d;
                        }
                    }
                    else
                    {
                        flagNoError = false;
                    }
                    break;
                case 8:
                    if (num2 != 0)
                    {
                        while (num1 >= num2)
                        {
                            num1 -= num2;
                        }
                        result = num1;
                    }
                    else
                    {
                        flagNoError = false;
                    }
                    break;
                case 9:
                    result = Math.Pow(num1, num2);
                    break;
                case 10:
                    result = Math.Sin(num1);
                    break;
                case 11:
                    result = Math.Cos(num1);
                    break;
                case 12:
                    result = Math.Tan(num1);
                    break;
                case 13:
                    if (num1 != 0)
                    {
                        result = 1 / Math.Tan(num1);
                    }
                    else
                    {
                        flagNoError = false;
                    }
                    break;
                case 14:
                    if (num1 >= 0)
                    {
                        result = Math.Log(num1);
                    }
                    else
                    {
                        flagNoError = false;
                    }
                    break;
                case 15:
                    if (num1 >= 0)
                    {
                        result = Math.Log10(num1);
                    }
                    else
                    {
                        flagNoError = false;
                    }
                    break;
                case 16:
                    if (num1 >= 0)
                    {
                        result = Math.Sqrt(num1);
                    }
                    else
                    {
                        flagNoError = false;
                    }
                    break;
                case 17:
                    result = Math.PI;
                    break;
                default:
                    result = 0d;
                    break;
            }
            return result;
        }
    }
 
}

using System;
 
namespace NoteCalcCon
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Введите выражение (для выхода - 0)");
            string stro = "";
            while (stro != "0")
            {
                stro = Console.ReadLine();
                if (Calculate.Solve(stro, out double otvet))
                {
                    Console.WriteLine($"{stro} = {otvet}");
                }
                else
                {
                    Console.WriteLine($"{stro} - где-то ошибка!");
                }
            }
        }
    }
 
}