C#实现eval 进行四则运算

     昨天在园子里看到有园友，写了相同标题的一篇文章。重点讲的是中缀表达式转换为后缀表达式的算法，但是实现的四则运算 有bug。其实我没看之前也不懂什么是 中缀和后缀表达式，之前有用过js eval 内置函数,后边一想貌似C#中是没有这样的一个函数，加上自己也没事，就试着自己写了下 这个所谓的四则运算。
    我没有研究计算机是怎么来进行四则运算的，我只是按自己的想法来实现 对 6-2*(5-3)+6/2*(6-3+3)/2 这样一个随意组合的四则运算表达式。
    我的思路是样的：
   <1> 先递归把表达式中的括号中的表达式给算出来，然后将值将之替换

        #region 计算括号中的表达式
        /// <summary>
        /// 获取括号中的计算表达式
        /// （递归）
        /// </summary>
        /// <param name="express"></param>
        public void GetBraceExpress(ref string express)
        {
            int leftBraceMaxIndex = -1;
            IList<int> rightBraceMinIndexs = new List<int>();
            for (int i = 0; i < express.Length; i++)
            {
                if (express[i].ToString() == "(")
                {
                    leftBraceMaxIndex = i;
                }
                if (express[i].ToString() == ")")
                {
                    rightBraceMinIndexs.Add(i);
                }
            }
            if (leftBraceMaxIndex != -1 && rightBraceMinIndexs.Count > 0)
            {
                int rightBraceIndex = 0;
                foreach (var item in rightBraceMinIndexs)
                {
                    if (item > leftBraceMaxIndex)
                    {
                        rightBraceIndex = item;
                        break;
                    }
                }

                string braceExpress = express.Substring(leftBraceMaxIndex, rightBraceIndex - leftBraceMaxIndex + 1);
                double result = CalcExpress(braceExpress.TrimStart('(').TrimEnd(')')); //计算（）中的表达式
                express = express.Replace(braceExpress, result.ToString());  //结果替换 （）表达式
                if (express.IndexOf("(") != -1 && express.IndexOf(")") != -1)
                {
                    GetBraceExpress(ref express);
                    return;
                }
            }
        }
        #endregion

        #region 计算表达式
        /// <summary>
        /// 计算表达式
        /// </summary>
        /// <param name="express">表达式</param>
        /// <returns>表达式结果</returns>
        public double CalcExpress(string express)
        {
            List<double> numbers = new List<double>(); //表达式中的数字
            List<char> operaters = new List<char>();   //表达式中的操作符
            int tempIndex = 0;
            for (int i = 0; i < express.Length; i++)
            {
                if (!char.IsNumber(express[i]) && char.IsNumber(express[i - 1]) && i > 0)
                {
                    if (tempIndex != 0)
                        tempIndex = tempIndex + 1;
                    numbers.Add(double.Parse(express.Substring(tempIndex, i - tempIndex)));
                    operaters.Add(express[i]);
                    tempIndex = i;
                }
            }
            numbers.Add(double.Parse(express.Substring(tempIndex + 1, express.Length - tempIndex - 1)));
            //开始计算
            double result = 0;
            if (operaters.Count == 0)
            {
                return double.Parse(express);
            }
            else
            {
                CalcMultiplyDivide(numbers, operaters); //计算乘除
                result = CalcAddSubduction(numbers, operaters); //计算加减
            }
            return result;
        }
        #endregion

 
   <2> 递归将 没有括号的表达式中的乘除计算，将结果替换 乘除表达式

        #region 计算乘除
        /// <summary>
        /// 递归计算表达式中的乘/除运算
        /// </summary>
        /// <param name="numbers">表达式中的数字集合</param>
        /// <param name="operaters">操作符集合</param>
        public void CalcMultiplyDivide(List<double> numbers, List<char> operaters)
        {
            for (int i = 0; i < operaters.Count; i++)
            {
                bool temp = false;
                double n = 0;
                if (operaters[i] == '*')
                {
                    n = numbers[i] * numbers[i + 1];
                    temp = true;
                }
                else if (operaters[i] == '/')
                {
                    n = numbers[i] / numbers[i + 1];
                    temp = true;
                }
                if (temp)
                {
                    operaters.RemoveAt(i);
                    numbers.RemoveRange(i, 2);
                    numbers.Insert(i, n);
                    CalcMultiplyDivide(numbers, operaters);
                    break;
                }
            }
        }
        #endregion

   <3> 递归算加减，直到表达式中没有操作符，然后返回结果。

        #region 计算加减
        /// <summary>
        /// 递归计算加减
        /// </summary> 
        /// <param name="numbers">表达式中的数字集合</param>
        /// <param name="operaters">操作符集合</param>
        /// <returns>计算的结果</returns>
        public double CalcAddSubduction(List<double> numbers, List<char> operaters)
        {

            for (int i = 0; i < operaters.Count; i++)
            {
                bool temp = false;
                double n = 0;
                if (operaters[i] == '+')
                {
                    n = numbers[i] + numbers[i + 1];
                    temp = true;
                }
                else if (operaters[i] == '-')
                {
                    n = numbers[i] - numbers[i + 1];
                    temp = true;
                }
                if (temp)
                {
                    operaters.RemoveAt(i);
                    numbers.RemoveRange(i, 2);
                    numbers.Insert(i, n);
                    CalcAddSubduction(numbers, operaters);
                    break;
                }
            }
            double result = 0;
            if (operaters.Count == 0)
                result = numbers[0];
            return result;
        }
        #endregion

这就可以实现像js eval 方法一样对一个四则运算表达式 计算了。这只是按我自己的思路来实现的，没有考虑性能啊什么的，如大家有什么好的法子，一起讨论下。
附上demo:https://files.cnblogs.com/joey0210/Calc.rar