public static string Presentation(string formula, FormulaParameter[] attributes, PresentationMode mode, object[][] values)
        {
            if (string.IsNullOrEmpty(formula))
            {
                return string.Empty;
            }

            string result = string.Empty;
            Regex rxLetter = new Regex(@"[a-zA-Z]");
            string letter = string.Empty;
            foreach (char ch in formula)
            {
                if (rxLetter.IsMatch(ch.ToString()))
                {
                    letter += ch;
                }
                else
                {
                    if (!string.IsNullOrEmpty(letter))
                    {
                        result = result + GetValue(letter, attributes, values);
                        letter = string.Empty;
                    }
                    result += ch;
                }
            }
            if (!string.IsNullOrEmpty(letter))
            {
                result = result + GetValue(letter, attributes, values);
            }
            return result;
        }
        public static string[] Validate(string formula, FormulaParameter[] attributes)
        {
            List<string> result = new List<string>();
            List<string> variables = new List<string>();

            Regex rx = new Regex(@"[a-zA-Z0-9 +-/*)(]");
            Regex rxSign = new Regex(@"[+-/*]");

            if (!string.IsNullOrEmpty(formula) && !rx.IsMatch(formula))
            {
                result.Add("Формула содержит некорректные символы");
            }
            else
            {
                string tempFormula = string.IsNullOrEmpty(formula) ? string.Empty : formula.Replace(" ", string.Empty);
                if (!string.IsNullOrEmpty(tempFormula))
                {
                    if (rxSign.IsMatch(tempFormula.Substring(0, 1)))
                    {
                        result.Add("Формула начинается знаком");
                    }
                    else
                    {
                        if (rxSign.IsMatch(tempFormula.Substring(tempFormula.Length - 1)))
                        {
                            result.Add("Формула заканчивается значком");
                        }
                        else
                        {
                            result.AddRange(ParseFormula(tempFormula, variables));
                        }
                    }
                }
                else {
                    result.Add("Формула не задана");
                }
            }

            if (attributes == null || attributes.Length == 0)
            {
                foreach (string variable in variables)
                {
                    result.Add("Переменная '" + variable + "' не объявлена в аттрибутах");
                }
            }
            else
            {
                foreach (string v in variables)
                {
                    string s = v.ToLower();
                    if (!attributes.Any(a => a.Code.ToLower() == s))
                    {
                        result.Add("Переменная '" + v + "' не объявлена в аттрибутах");
                    }
                }
            }
            if (variables.Count == 0)
            {
                if (attributes != null)
                {
                    foreach (FormulaParameter a in attributes)
                    {
                        result.Add("Аттрибут '" + a.Name + "' не используется в формуле");
                    }
                }
            }
            else
            {
                if (attributes != null)
                {
                    foreach (FormulaParameter a in attributes)
                    {
                        string s = a.Code.ToLower();
                        if (!variables.Any(v => v.ToLower() == s))
                        {
                            result.Add("Аттрибут '" + a.Name + "' не используется в формуле");
                        }
                    }
                }
            }

            if (attributes != null)
            {
                foreach (FormulaParameter a in attributes)
                {
                    string s = a.Code.ToLower();
                    if (attributes.Count(v => v.Code.ToLower() == s) != 1)
                    {
                        result.Add("Аттрибут '" + a.Name + "' объявлен более одного раза");
                    }
                }
            }

            return result.ToArray();
        }
 public static string PresentationDemo(string formula, FormulaParameter[] attributes, object[][] values)
 {
     return Presentation(formula, attributes, PresentationMode.DemoMode, values);
 }
 public static decimal CalculateDemo(string expression, FormulaParameter[] attributes, object[][] values)
 {
     string presentatonForm = PresentationDemo(expression, attributes, values).Replace(" ", string.Empty);
     return CalcInnerLine(presentatonForm);
 }
 public static decimal CalcPreDefinedValue(FormulaParameter attr, object[][] values)
 {
     object[] vl = values.FirstOrDefault(v => ((string)v[0]) == attr.Code);
     return vl == null || vl.Length == 0 ? 0 : (decimal)vl[1];
 }
 internal static void SaveFormulaParameter(FormulaParameter p, int fid)
 {
     using (var con = OpenOrCreateDb())
     {
         try
         {
             //"CREATE TABLE calcFormulaParams (paramId int IDENTITY(1,1) NOT NULL, formulaId int not null,
             //typeid int, paramValue numeric(20, 4), name nvarchar(100) not null, code nvarchar(10) not null);",
             using (var command = con.CreateCommand())
             {
                 int t = 0;
                 if (!String.IsNullOrEmpty(p.TypeName))
                 {
                     command.CommandText = "select min(predicateid) FROM Predicates where  predicatevalue = '" +
                                             p.TypeName + "'";
                     var i = command.ExecuteScalar();
                     t = i == null || i is DBNull ? 0 : (int)i;
                 }
                 command.CommandText = p.Id == 0
                     ? string.Format("insert into calcFormulaParams(formulaId, typeid, paramValue, name, code) " +
                     " values ({0},{1},{2}, '{3}', '{4}')", fid, t, p.Value, p.Name, p.Code)
                     : string.Format("update calcFormulaParams set typeid={0}, paramValue={1}, name='{2}', code='{3}' "
                     + " where  paramId={4} and formulaId={5}", t, p.Value, p.Name, p.Code, p.Id, fid);
                 command.ExecuteNonQuery();
             }
         }
         catch { }
         finally { con.Close(); }
     }
 }