C#实现计算公式从字符串到数字的转换

以下是类的实现代码，可以使用工具生成一个dll文件到时候加入引用就可以了。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Web;
using System.Drawing;
using System.Data.Common;
using System.Web.UI;
using System.IO;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Configuration.Internal;
using System.Configuration;

namespace HR.Common.Common
{
    public class sszone_StringToFloat
    {
        //计算公式的相关函数
        /// <summary>
        /// 把单个字符“0”、“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”、“9”转化为数字0、1、2、3、4、5、6、7、8、9
        /// </summary>
        /// <param name="nChart"></param>
        /// <returns></returns>
        public int ChartToInt(string nChart)
        {
            int Intd = Int32.Parse(nChart.ToString());
            return Intd;
        }
        /// <summary>
        /// 把字符串“123.456”转化为数字123.456
        /// </summary>
        /// <param name="nCharts"></param>
        /// <returns></returns>
        public float ChartsToFloat(string nCharts)
        {
            float realInt = 0;
            int chartslenght = 0;
            chartslenght = nCharts.Length;
            int DotAtIndex = 0;
            DotAtIndex = nCharts.IndexOf('.');
            if (DotAtIndex == -1)//没有小数点，是整数
            {
                for (int i = 0; i < chartslenght; i++)
                {
                    int tempint = 0;
                    tempint = ChartToInt(nCharts.ElementAt(i).ToString());
                    for (int j = chartslenght - 1 - i; j > 0; j--)
                    {
                        tempint = tempint * 10;
                    }
                    realInt += tempint;
                }
            }
            else//有小数点，是小数
            {
                for (int i = 0; i < DotAtIndex; i++)//整数部分
                {
                    int tempint = 0;
                    tempint = ChartToInt(nCharts.ElementAt(i).ToString());
                    for (int j = DotAtIndex - 1 - i; j > 0; j--)
                    {
                        tempint = tempint * 10;
                    }
                    realInt += tempint;
                }
                for (int i = DotAtIndex + 1; i < chartslenght; i++)//小数部分
                {
                    float tempint = 0;
                    tempint = ChartToInt(nCharts.ElementAt(i).ToString());
                    for (int j = chartslenght - i; j > 0; j--)
                    {
                        tempint = (float)(tempint * 0.1);
                    }
                    realInt += tempint;
                }
            }
            return realInt;

        }
        /// <summary>
        /// 计算两个数，浮点数，包括加减乘除运算
        /// </summary>
        /// <param name="nFirstNumber">第一个数</param>
        /// <param name="nSecondNumber">第二个数</param>
        /// <param name="nCharater">运算符号</param>
        /// <returns></returns>
        public float CaculateTwoNumber(float nFirstNumber, float nSecondNumber, string nCharater)
        {
            float nResult = 0;
            if (nCharater == "+")
            {
                nResult = nFirstNumber + nSecondNumber;
            }
            if (nCharater == "-")
            {
                nResult = nFirstNumber - nSecondNumber;
            }
            if (nCharater == "*")
            {
                nResult = nFirstNumber * nSecondNumber;
            }
            if (nCharater == "/")
            {
                nResult = nFirstNumber * nSecondNumber;
            }
            return nResult;
        }
        /// <summary>
        /// 根据传递进来的字符串，只含有数字和“*”或“/”符号，计算出结果
        /// </summary>
        /// <param name="nnumberstr">只含有数字和“*”或“/”符号的字符串</param>
        /// <returns></returns>
        public double ReturnMultAndDevResult(string nnumberstr)
        {
            double realResult = 0;
            ///查找运算符
            int nMultorDev = 0;//代表是乘法还是除法，0是乘法，1是除法
            nMultorDev = nnumberstr.IndexOf('*');
            if (nMultorDev <= 0)
            {
                nMultorDev = 1;//没有找到“*”，是除法
            }
            else
            {
                nMultorDev = 0;//找到“*”，是乘法
            }

            ///分割运算符和数字
            double FirstNumber = 0;
            double SecondNumber = 0;
            string FirstNumberString = "";
            string SecondNumberString = "";
            //int FirstNumberStringLength = 0;
            //int SecondNumberStringLength = 0;
            if (nMultorDev == 0)//乘法
            {
                string[] numberstringlistMult = nnumberstr.Split('*');
                FirstNumberString = numberstringlistMult[0].ToString();
                SecondNumberString = numberstringlistMult[1].ToString();
                //FirstNumberStringLength = FirstNumberString.Length;
                //SecondNumberStringLength = SecondNumberString.Length;

                ///转化为数字

                FirstNumber = ChartsToFloat(FirstNumberString);
                //FirstNumber = Double.Parse(FirstNumber.ToString());
                SecondNumber = ChartsToFloat(SecondNumberString);
                //SecondNumber = Double.Parse(SecondNumber.ToString());
                FirstNumber = Math.Round(FirstNumber, 2);
                SecondNumber = Math.Round(SecondNumber, 2);
                ///计算两个数字的运算结果

                realResult = FirstNumber * SecondNumber;
                realResult = Math.Round(realResult, 2);
            }
            else
            {
                string[] numberstringlistDev = nnumberstr.Split('/');
                FirstNumberString = numberstringlistDev[0].ToString();
                SecondNumberString = numberstringlistDev[1].ToString();
                ///转化为数字

                FirstNumber = ChartsToFloat(FirstNumberString);
                SecondNumber = ChartsToFloat(SecondNumberString);
                FirstNumber = Math.Round(FirstNumber, 2);
                SecondNumber = Math.Round(SecondNumber, 2);
                ///计算两个数字的运算结果

                realResult = FirstNumber / SecondNumber;
                realResult = Math.Round(realResult, 2);
            }


            return realResult;
        }

        /// <summary>
        /// 根据传递进来的字符串，只含有数字和“+”或“-”符号，计算出结果
        /// </summary>
        /// <param name="nnumberstr">只含有数字和“+”或“-”符号的字符串</param>
        /// <returns></returns>
        public float ReturnPlusAndCutResult(string nnumberstr)
        {
            float realResult = 0;
            ///查找运算符
            int nPlusAndCut = 0;//代表是加法还是减法，0是加法，1是减法
            nPlusAndCut = nnumberstr.IndexOf('+');
            if (nPlusAndCut <= 0)
            {
                nPlusAndCut = 1;//没有找到“-”，是减法
            }
            else
            {
                nPlusAndCut = 0;//找到“+”，是加法
            }

            ///分割运算符和数字
            float FirstNumber = 0;
            float SecondNumber = 0;
            string FirstNumberString = "";
            string SecondNumberString = "";
            //int FirstNumberStringLength = 0;
            //int SecondNumberStringLength = 0;
            if (nPlusAndCut == 0)//加法
            {
                string[] numberstringlistMult = nnumberstr.Split('+');
                FirstNumberString = numberstringlistMult[0].ToString();
                SecondNumberString = numberstringlistMult[1].ToString();
                //FirstNumberStringLength = FirstNumberString.Length;
                //SecondNumberStringLength = SecondNumberString.Length;

                ///转化为数字

                FirstNumber = ChartsToFloat(FirstNumberString);
                SecondNumber = ChartsToFloat(SecondNumberString);

                ///计算两个数字的运算结果

                realResult = FirstNumber + SecondNumber;
            }
            else
            {
                string[] numberstringlistDev = nnumberstr.Split('-');
                FirstNumberString = numberstringlistDev[0].ToString();
                SecondNumberString = numberstringlistDev[1].ToString();
                ///转化为数字

                FirstNumber = ChartsToFloat(FirstNumberString);
                SecondNumber = ChartsToFloat(SecondNumberString);

                ///计算两个数字的运算结果

                realResult = FirstNumber - SecondNumber;
            }


            return realResult;
        }

        /// <summary>
        /// 返回括号里面的内容，可能含有加法、减法、乘法和除法，但是没有括号
        /// </summary>
        /// <param name="nCharaterString"></param>
        /// <returns></returns>
        public string FindOutsideStringInBrackets(string nCharaterString)
        {
            string ResultString = "";
            int startindex = 0;
            int endindex = 0;
            int substartindex = 0;
            int subendindex = 0;
            int countBrackets = 0;
            int exitid = 0;
            int strlenght = 0;
            strlenght = nCharaterString.Length;
            exitid = nCharaterString.IndexOf('(');
            if (exitid != -1)//有括号在字符串里
            {
                startindex = nCharaterString.IndexOf('(');
                endindex = nCharaterString.IndexOf(')');
                string subCharaterstring = nCharaterString.Substring(startindex, endindex - startindex);
                strlenght = subCharaterstring.Length;
                for (int curindex = 0; curindex < strlenght; )//得到左括号的个数
                {
                    subCharaterstring = subCharaterstring.Substring(curindex);
                    strlenght = subCharaterstring.Length;
                    substartindex = subCharaterstring.IndexOf('(');
                    if (substartindex != -1)
                    {
                        countBrackets++;
                        curindex = substartindex + 1;

                    }
                    else
                    {
                        curindex++;
                    }

                }
                subCharaterstring = nCharaterString.Substring(endindex);
                strlenght = subCharaterstring.Length;
                //while (countBrackets > 0)//根据左括号的个数查找到对应的右括号的序号
                //{
                for (int curindex = 0; curindex < strlenght && countBrackets > 0; )
                {
                    subCharaterstring = subCharaterstring.Substring(curindex);
                    strlenght = subCharaterstring.Length;
                    subendindex = subCharaterstring.IndexOf(')');
                    if (subendindex != -1)
                    {
                        countBrackets--;
                        curindex = subendindex + 1;
                        endindex += subendindex + 1;//找到右括号，跳转增加
                    }
                    else
                    {
                        curindex++;
                        endindex++;//没有找到括号，逐个增加
                    }

                }

                //}               
                ResultString = nCharaterString.Substring(startindex + 1, endindex - 1 - startindex - 1);
                ResultString = FindOutsideStringInBrackets(ResultString);//递归调用函数
                return ResultString;
            }
            else      //没有括号在字符串里
            {
                ResultString = nCharaterString;
                return ResultString;
            }

        }
        /// <summary>
        /// 返回括号里的字符串的结果的字符串
        /// </summary>
        /// <param name="nstrBrackets"></param>
        /// <returns></returns>
        public string ReturnStringInBrackets(string nstrBrackets)
        {
            char[] FourArr = { '+', '-', '*', '/' };
            int Fourcount = 0;
            Fourcount = nstrBrackets.IndexOfAny(FourArr);
            if (Fourcount < 0)
            {
                return nstrBrackets;
            }
            string[] stroutPandC = nstrBrackets.Split('+', '-');
            int stritemcount = stroutPandC.Length;//记录有多少个加减号+1
            string strCharatersIndexList = "";
            int strlength = nstrBrackets.Length;
            string tempstr = "";
            tempstr = nstrBrackets.ToString();
            char[] strchars = { '+', '-' };
            for (int indexid = 0; indexid < strlength; )//找出+号和-号的位置，记录+号和-号的顺序
            {
                int tempid = 0;
                tempid = tempstr.IndexOfAny(strchars);
                if (tempid > 0)
                {

                    if (strCharatersIndexList == "")
                    {
                        strCharatersIndexList += tempstr.ElementAt(tempid).ToString();//记录下符号是哪个符号
                    }
                    else
                    {
                        strCharatersIndexList += "|";
                        strCharatersIndexList += tempstr.ElementAt(tempid).ToString();
                    }
                    tempstr = tempstr.Substring(tempid + 1);
                    indexid = tempid;
                }
                else
                {
                    break;
                }

            }
            int strChartatersIndexListLength = 0;
            strChartatersIndexListLength = (strCharatersIndexList.Length + 1) / 2;//运算符的个数
            string[] strChartatersIndexListArry = strCharatersIndexList.Split('|');
            string tempMDresultstr = "";//保存最后的结果，运算过程中也会用到
            for (int indexid = 0; indexid < stritemcount; indexid++)// 替换含有*、/号的字符串
            {

                if (stroutPandC[indexid].ToString().IndexOf('*') > 0 || stroutPandC[indexid].ToString().IndexOf('/') > 0)//存在乘除运算
                {
                    char[] MDcharArr = { '*', '/' };
                    int strMDlength = stroutPandC[indexid].Length;
                    //分割*、/符号，保存数字
                    string[] strMDlist = stroutPandC[indexid].ToString().Split(MDcharArr);
                    //记录数字个数
                    int strMDListLength = (strMDlist.Length + 1) / 2;
                    //记录*、/符号的位置
                    string strMDindexlist = "";
                    string tempMDstr = "";
                    tempMDstr = stroutPandC[indexid].ToString();
                    for (int mdindexid = 0; mdindexid < strMDlength; )//找出*、/的位置
                    {
                        int mdtempid = 0;
                        mdtempid = tempMDstr.IndexOfAny(MDcharArr);
                        if (mdtempid > 0)
                        {

                            if (strMDindexlist == "")
                            {
                                strMDindexlist += tempMDstr.ElementAt(mdtempid).ToString();//顺序记录下符号是哪个符号
                            }
                            else
                            {
                                strMDindexlist += "|";
                                strMDindexlist += tempMDstr.ElementAt(mdtempid).ToString();
                            }
                            tempMDstr = tempMDstr.Substring(mdtempid + 1);
                            mdindexid = mdtempid;
                        }
                        else
                        {
                            break;
                        }

                    }
                    //根据数字和*、/符号的顺序位置，计算出结果
                    tempMDresultstr = "";
                    string tempMDresultinstr = "";
                    double tempMDresult = 0;
                    int strMDindexlistLength = (strMDindexlist.Length + 1) / 2;
                    string[] strMDindexlistArry = strMDindexlist.Split('|');
                    for (int strMDindexlistid = 0; strMDindexlistid < strMDindexlistLength; strMDindexlistid++)
                    {
                        if (strMDindexlistid == 0)
                        {
                            tempMDresultstr = strMDlist[0].ToString();
                        }
                        else
                        {
                            //tempMDresultstr = strMDlist[strMDindexlistid + 1].ToString();
                        }
                        tempMDresultinstr = tempMDresultstr + strMDindexlistArry[strMDindexlistid].ToString() + strMDlist[strMDindexlistid + 1].ToString();
                        tempMDresult = ReturnMultAndDevResult(tempMDresultinstr);
                        tempMDresultstr = tempMDresult.ToString();//运算结果
                    }
                    stroutPandC[indexid] = tempMDresultstr;
                    if (stritemcount <= 0)
                    {
                        return tempMDresultstr.ToString();//运算结果
                    }
                }
                else//没有乘除，只有加减运算
                {

                }
            }

            //根据数字和+、-符号的顺序位置，计算出结果
            string tempPCresultinstr = "";
            float tempPCresult = 0;
            //int strPCindexlistLength = strCharatersIndexList.Length;
            for (int strPCindexlistid = 0; strPCindexlistid < strChartatersIndexListLength; strPCindexlistid++)
            {
                if (strPCindexlistid == 0)
                {
                    tempMDresultstr = stroutPandC[0].ToString();
                }
                else
                {
                    //tempMDresultstr = strMDlist[strMDindexlistid + 1].ToString();
                }


                tempPCresultinstr = tempMDresultstr + strChartatersIndexListArry[strPCindexlistid].ToString() + stroutPandC[strPCindexlistid + 1].ToString();
                tempPCresult = ReturnPlusAndCutResult(tempPCresultinstr);
                tempMDresultstr = tempPCresult.ToString();//运算结果
            }
            return tempMDresultstr.ToString();//运算结果

        }

        /// <summary>
        /// 返回添加括号后的公式字符串
        /// </summary>
        /// <param name="nInString"></param>
        /// <returns></returns>
        public string ReturnAddBracketsString(string nInString)
        {
            //nInString = "(" + nInString + ")";
            string OutString = "";
            char[] BracketsArr = { '(', ')' };
            char[] FourCharatersArr = { '+', '-', '*', '/' };
            char[] TowCharatersArr = { '+', '-' };
            char[] NFourCharatersArr = { '+', '-', '(', ')' };
            char[] MDTowCharatersArr = { '*', '/' };
            int InStringLength = nInString.Length;
            //int FirstNFIndex = 0;
            //int SecondNFIndex = 0;
            //int IsExistNFIndex = -2;
            string[] InStringSplitNFourArr = nInString.Split(NFourCharatersArr);
            int InStringSplitNFourArrLength = InStringSplitNFourArr.Length;
            string InStringSplitNFourArrCharaters = "";
            string tempInStringSplitNFourArrCharaters = nInString;
            for (int tempindstringsplitid = 0; tempindstringsplitid < InStringLength; )//保存分割的符号
            {
                tempInStringSplitNFourArrCharaters = tempInStringSplitNFourArrCharaters.Substring(tempindstringsplitid);
                int elementid = tempInStringSplitNFourArrCharaters.IndexOfAny(NFourCharatersArr);
                if (elementid >= 0)
                {
                    if (InStringSplitNFourArrCharaters == "")
                    {
                        InStringSplitNFourArrCharaters = tempInStringSplitNFourArrCharaters.ElementAt(elementid).ToString();
                    }
                    else
                    {
                        InStringSplitNFourArrCharaters += "|" + tempInStringSplitNFourArrCharaters.ElementAt(elementid).ToString();
                    }
                    tempindstringsplitid = elementid + 1;
                }
                else
                {
                    tempindstringsplitid = InStringLength;
                }

            }
            string[] InStringSplitNFourArrCharatersArr = InStringSplitNFourArrCharaters.Split('|');
            int InStringSplitNFourArrCharatersLength = InStringSplitNFourArrCharatersArr.Length;

            for (int CKindexid = 0; CKindexid < InStringSplitNFourArrLength; CKindexid++)//添加括号
            {

                if (InStringSplitNFourArr[CKindexid].ToString().Length <= 0)
                {
                    continue;
                }
                char Mult;
                Mult = InStringSplitNFourArr[CKindexid].ToString().ElementAt(0);
                if (Mult == '*' || Mult == '/')
                {
                    int rightcout = 0;
                    //int leftindexid = -1;
                    int firstleftindexid = -1;
                    string pertempstring = "";
                    for (int perid = CKindexid - 1; perid >= 0; perid--)
                    {
                        int tempindexid = InStringSplitNFourArr[perid].IndexOf(')');
                        if (tempindexid > 0)
                        {
                            rightcout++;
                        }
                        int templeftindexid = InStringSplitNFourArr[perid].IndexOf('(');
                        if (templeftindexid >= 0)
                        {
                            rightcout--;
                            if (rightcout == 0)
                            {
                                firstleftindexid = perid;
                                break;
                            }
                        }
                    }

                    if ((firstleftindexid - rightcout) >= 0)
                    {
                        int MDcount = InStringSplitNFourArr[CKindexid].ToString().Split(MDTowCharatersArr).Length;
                        //插入第一个“(”
                        pertempstring = InStringSplitNFourArr[firstleftindexid - rightcout].ToString();
                        pertempstring = pertempstring.Insert(0, "(");
                        InStringSplitNFourArr[firstleftindexid - rightcout] = pertempstring;

                        //插入最后“)”
                        pertempstring = InStringSplitNFourArr[CKindexid].ToString();
                        int nextlength = InStringSplitNFourArr[CKindexid].ToString().Length;
                        pertempstring = pertempstring.Insert(nextlength, ")");
                        InStringSplitNFourArr[CKindexid] = pertempstring;

                        string tempbackstring = "";
                        int perid = InStringSplitNFourArr[CKindexid].ToString().Length - 1;
                        for (int indexid = 0; indexid < MDcount - 1; indexid++)
                        {
                            //循环插入“(”
                            pertempstring = InStringSplitNFourArr[firstleftindexid - rightcout].ToString();
                            pertempstring = pertempstring.Insert(0, "(");
                            InStringSplitNFourArr[firstleftindexid - rightcout] = pertempstring;

                            //循环插入“)”
                            tempbackstring = InStringSplitNFourArr[CKindexid].ToString().Substring(0, perid);
                            perid = tempbackstring.LastIndexOfAny(MDTowCharatersArr);
                            tempbackstring = InStringSplitNFourArr[CKindexid].ToString();
                            tempbackstring = tempbackstring.Insert(perid, ")");
                            InStringSplitNFourArr[CKindexid] = tempbackstring;
                        }


                    }

                }
                else
                {
                    if (InStringSplitNFourArr[CKindexid].ToString().Length >= 3)//至少有5个元素，3个数字和2个符号
                    {
                        string[] tempCKArr = InStringSplitNFourArr[CKindexid].ToString().Split(MDTowCharatersArr);
                        int tempCKArrLength = tempCKArr.Length;
                        string savetempstring = InStringSplitNFourArr[CKindexid].ToString();
                        if (tempCKArrLength >= 2)//至少有3个元素，3个数字
                        {
                            int addcount = 0;
                            for (int addindexid = 2; addindexid < tempCKArrLength; addindexid++)
                            {
                                int insertindexlength = 0;
                                for (int addcountid = 0; addcountid < addindexid; addcountid++)
                                {
                                    insertindexlength += tempCKArr[addcountid].ToString().Length;
                                    insertindexlength += 1;
                                }
                                savetempstring = savetempstring.Insert(0, "(");
                                savetempstring = savetempstring.Insert(insertindexlength + addcount, ")");
                                addcount += 2;
                            }
                            savetempstring = savetempstring.Insert(0, "(");
                            int savetempstringlength = savetempstring.Length;
                            savetempstring = savetempstring.Insert(savetempstringlength, ")");
                            InStringSplitNFourArr[CKindexid] = savetempstring;
                        }

                    }
                }


            }
            string resultstr = "";
            string tempresult = "";
            for (int addindexid = 0; addindexid < InStringSplitNFourArrCharatersLength; addindexid++)
            {
                if (addindexid == 0)
                {
                    if (InStringSplitNFourArrLength <= 1)
                    {
                        tempresult = InStringSplitNFourArr[0].ToString();
                    }
                    else
                    {
                        tempresult = InStringSplitNFourArr[0].ToString() + InStringSplitNFourArrCharatersArr[addindexid].ToString() + InStringSplitNFourArr[1].ToString();
                    }
                    
                    continue;
                }
                else
                {
                    resultstr = tempresult + InStringSplitNFourArrCharatersArr[addindexid].ToString() + InStringSplitNFourArr[addindexid + 1].ToString();
                    tempresult = resultstr;
                    continue;
                }
                //resultstr = tempresult + InStringSplitNFourArrCharatersArr[addindexid].ToString() + InStringSplitNFourArr[addindexid + 1].ToString();
                //tempresult = resultstr;

            }
            //resultstr = resultstr.Insert(0, "(");
            //int resultstrlength = resultstr.Length;
            //resultstr = resultstr.Insert(resultstrlength, ")");
            //OutString = resultstr;
            tempresult = tempresult.Insert(0, "(");
            int tempresultstrlength = tempresult.Length;
            tempresult = tempresult.Insert(tempresultstrlength, ")");
            OutString = tempresult;
            return OutString;
        }

        /// <summary>
        /// 循环调用该函数，传入括号的内容，返回所有运算的最总结果字符串
        /// </summary>
        /// <param name="nInString">括号内的内容，包括最外围的括号</param>
        /// <param name="nStartIndex">开始位置</param>
        /// <param name="nEndIndex">结束位置</param>
        /// <returns></returns>
        public string ReturnFinalResultString(string nInString, int nStartIndex, int nEndIndex)
        {
            string TempResultString = "";
            int StartIndexLeft = 0;
            int EndIndexRight = 0;
            //int TempIndex = 0;
            char LeftBracket = '(';
            char RightBracket = ')';
            char[] FourCharArr = { '+', '-', '*', '/' };
            int InStringLength = 0;
            string SubLeftInString = "";
            //int SubLeftInStringLength = 0;
            string tempString = "";
            //float TempResult = 0;
            string TempSubString = "";

            InStringLength = nInString.Length;
            SubLeftInString = nInString.Substring(0, InStringLength);
            EndIndexRight = SubLeftInString.IndexOf(RightBracket);
            tempString = SubLeftInString.Substring(0, EndIndexRight);
            StartIndexLeft = tempString.LastIndexOf(LeftBracket);
            if (StartIndexLeft >= 0 || EndIndexRight >= 0)
            {
                if (StartIndexLeft >= 0)
                {
                    TempSubString = nInString.Substring(StartIndexLeft + 1, EndIndexRight - StartIndexLeft - 1);//取出括号内的内容
                    TempResultString = ReturnStringInBrackets(TempSubString);//返回括号内的结果
                    TempSubString = nInString.Remove(StartIndexLeft, EndIndexRight - StartIndexLeft + 1);
                    TempSubString = TempSubString.Insert(StartIndexLeft, TempResultString);

                    char[] TowBracketsArr = { '(', ')' };
                    int count = TempSubString.IndexOfAny(TowBracketsArr);
                    if (count >= 0)
                    {
                        TempSubString = ReturnFinalResultString(TempSubString, 0, 0);//递归调用
                    }
                }
                
            }
            TempResultString = TempSubString;
            //for (int indexid = 0; indexid < InStringLength; indexid++)
            //{

            //}
            return TempResultString;
        }
        //公式的计算算法结束//
    }
}

　　

转载于:https://www.cnblogs.com/sszjone/archive/2011/11/13/2247079.html