C#字尾表示式解析計算字串公式

public enum BracketEnum
{
    /// <summary>
    /// Undefined
    /// </summary>
    Undefined = 0,
    /// <summary>
    /// 左括號
    /// </summary>
    Open,
    /// <summary>
    /// 右括號
    /// </summary>
    Close
}

public enum NodeTypeEnum
{
    /// <summary>
    /// Null
    /// </summary>
    Null = 0,
    /// <summary>
    /// 運算元
    /// </summary>
    Number,
    /// <summary>
    /// 操作符
    /// </summary>
    Operator,
    /// <summary>
    /// 括號
    /// </summary>
    Bracket,
}

public enum OperatorEnum
{
    /// <summary>
    /// Undefined
    /// </summary>
    Undefined = 0,
    /// <summary>
    /// +
    /// </summary>
    Plus,
    /// <summary>
    /// -
    /// </summary>
    Minus,
    /// <summary>
    /// *
    /// </summary>
    Multiply,
    /// <summary>
    /// /
    /// </summary>
    Divide,
    /// <summary>
    /// ^
    /// </summary>
    Power,
}

public class BracketNode : BaseNode
    {
        /// <summary>
        /// 括號值
        /// </summary>
        public BracketEnum Bracket { get; }
        /// <summary>
        /// 公式括號節點
        /// </summary>
        public BracketNode(BracketEnum bracket) : base(NodeTypeEnum.Bracket)
        {
            Bracket = bracket;
        }
    }

public class NumberNode : BaseNode
    {
        /// <summary>
        /// 數位值
        /// </summary>
        public double Number { get; }
        public NumberNode(double number) : base(NodeTypeEnum.Number)
        {
            Number = number;
        }
    }

public class OperatorNode : BaseNode
    {
        /// <summary>
        /// 操作字串列舉
        /// </summary>
        public OperatorEnum OperatorKey { get; }
        /// <summary>
        /// 優先順序
        /// </summary>
        public int Priority { get; }
        public OperatorNode(OperatorEnum operatorKey) : base(NodeTypeEnum.Operator)
        {
            OperatorKey = operatorKey;
            Priority = GetPriority();
        }
        private int GetPriority()
        {
            var priority = OperatorKey switch
            {
                OperatorEnum.Power => 6,
                OperatorEnum.Multiply => 5,
                OperatorEnum.Divide => 5,
                OperatorEnum.Plus => 4,
                OperatorEnum.Minus => 4,
                _ => 0
            };
            return priority;
        }
    }

public static class BracketReader
    {
        /// <summary>
        /// 左右括號字元
        /// </summary>
        private const char OPEN_BRACKET_CHAR = '(';
        private const char CLOSE_BRACKET_CHAR = ')';
        /// <summary>
        /// 嘗試獲取左括號
        /// </summary>
        /// <param name="nodes">公式節點資訊</param>
        /// <param name="formula">公式字元</param>
        /// <param name="index">公式讀取的下標</param>
        /// <returns></returns>
        public static bool TryProceedOpenBracket(List<BaseNode> nodes, ReadOnlySpan<char> formula, ref int index)
        {
            if (formula[index].Equals(OPEN_BRACKET_CHAR))
            {
                nodes.Add(new BracketNode(BracketEnum.Open));
                return true;
            }
            return false;
        }
        /// <summary>
        /// 嘗試獲取右括號
        /// </summary>
        /// <param name="nodes">公式節點資訊</param>
        /// <param name="formula">公式字元</param>
        /// <param name="index">公式讀取的下標</param>
        /// <returns></returns>
        public static bool TryProceedCloseBracket(List<BaseNode> nodes, ReadOnlySpan<char> formula, ref int index)
        {
            if (formula[index].Equals(CLOSE_BRACKET_CHAR))
            {
                nodes.Add(new BracketNode(BracketEnum.Close));
                return true;
            }
            return false;
        }
    }

    public static class NumberReader
    {
        /// <summary>
        /// 嘗試讀取數位
        /// </summary>
        public static bool TryProceedNumber(List<BaseNode> nodes, ReadOnlySpan<char> formula, ref int index)
        {
            double value = 0;
            var isTry = false;//是否轉換成功
            var isNegative = formula[index] == '-';//是否是負數
            var localIndex = isNegative ? index + 1 : index;
            //迴圈判斷數位
            for (int i = localIndex; i < formula.Length; i++)
            {
                var ch = formula[i];
                var isLastChar = i + 1 == formula.Length;
                
                if (IsFloatingNumber(ch))
                {
                    //如果最後一個並且成功
                    if (isLastChar && double.TryParse(formula.Slice(index, formula.Length - index), out value))
                    {
                        index = i;
                        isTry = true;
                        break;
                    }
                }
                else if(double.TryParse(formula.Slice(index, i - index), out value))
                {
                    //如果不是數位比如是字母，則直接判斷之前的數位
                    index = i - 1;
                    isTry = true;
                    break;
                }
                else
                {
                    break;
                }
            }
            if (isTry)
            {
                nodes.Add(new NumberNode(value));
            }
            return isTry;
        }
        /// <summary>
        /// 判斷是不是數位或者.
        /// </summary>
        /// <param name="ch">字元</param>
        /// <returns></returns>
        private static bool IsFloatingNumber(char ch)
        {
            //是不是十進位制數
            var isDigit = char.IsDigit(ch);
            return isDigit || ch == '.';
        }
    }

    /// <summary>
    /// 操作符解讀
    /// </summary>
    public static class OperatorReader
    {
        private static readonly string[] _operators = new[] { "+", "-", "*", "/", "^" };

        /// <summary>
        /// 嘗試獲取操作符
        /// </summary>
        public static bool TryProceedOperator(List<BaseNode> nodes, ReadOnlySpan<char> formula, ref int index)
        {
            if (_operators.Contains(formula[index].ToString()))
            {
                nodes.Add(new OperatorNode(GetOperatorKey(formula[index].ToString())));
                return true;
            }
            return false;
        }
        /// <summary>
        /// 獲取對應列舉
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        private static OperatorEnum GetOperatorKey(string name)
        {
            return name switch
            {
                "+" => OperatorEnum.Plus,
                "-" => OperatorEnum.Minus,
                "*" => OperatorEnum.Multiply,
                "/" => OperatorEnum.Divide,
                "^" => OperatorEnum.Power,

                _ => OperatorEnum.Undefined
            };
        }
    }