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 = -;
             IList<int> rightBraceMinIndexs = new List<int>();
             for (int i = ; i < express.Length; i++)
             {
                 if (express[i].ToString() == "(")
                 {
                     leftBraceMaxIndex = i;
                 }
                 if (express[i].ToString() == ")")
                 {
                     rightBraceMinIndexs.Add(i);
                 }
             }
             if (leftBraceMaxIndex != - && rightBraceMinIndexs.Count > )
             {
                 int rightBraceIndex = ;
                 foreach (var item in rightBraceMinIndexs)
                 {
                     if (item > leftBraceMaxIndex)
                     {
                         rightBraceIndex = item;
                         break;
                     }
                 }

                 string braceExpress = express.Substring(leftBraceMaxIndex, rightBraceIndex - leftBraceMaxIndex + );
                 double result = CalcExpress(braceExpress.TrimStart('(').TrimEnd(')')); //计算（）中的表达式
                 express = express.Replace(braceExpress, result.ToString());  //结果替换 （）表达式
                 if (express.IndexOf("(") != - && express.IndexOf(")") != -)
                 {
                     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 = ;
             for (int i = ; i < express.Length; i++)
             {
                 if (!char.IsNumber(express[i]) && char.IsNumber(express[i - ]) && i > )
                 {
                     if (tempIndex != )
                         tempIndex = tempIndex + ;
                     numbers.Add(double.Parse(express.Substring(tempIndex, i - tempIndex)));
                     operaters.Add(express[i]);
                     tempIndex = i;
                 }
             }
             numbers.Add(double.Parse(express.Substring(tempIndex + , express.Length - tempIndex - )));
             //开始计算
             double result = ;
             if (operaters.Count == )
             {
                 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 = ; i < operaters.Count; i++)
             {
                 bool temp = false;
                 double n = ;
                 if (operaters[i] == '*')
                 {
                     n = numbers[i] * numbers[i + ];
                     temp = true;
                 }
                 else if (operaters[i] == '/')
                 {
                     n = numbers[i] / numbers[i + ];
                     temp = true;
                 }
                 if (temp)
                 {
                     operaters.RemoveAt(i);
                     numbers.RemoveRange(i, );
                     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 = ; i < operaters.Count; i++)
             {
                 bool temp = false;
                 double n = ;
                 if (operaters[i] == '+')
                 {
                     n = numbers[i] + numbers[i + ];
                     temp = true;
                 }
                 else if (operaters[i] == '-')
                 {
                     n = numbers[i] - numbers[i + ];
                     temp = true;
                 }
                 if (temp)
                 {
                     operaters.RemoveAt(i);
                     numbers.RemoveRange(i, );
                     numbers.Insert(i, n);
                     CalcAddSubduction(numbers, operaters);
                     break;
                 }
             }
             double result = ;
             if (operaters.Count == )
                 result = numbers[];
             return result;
         }
         #endregion

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