Code666 (代码贴、代码片段)

[C#] C#执行字符串参数的运算表达式 →→→→→进入此内容的聊天室

来自 , 2020-05-20, 写在 C#, 查看 107 次.
URL http://www.code666.cn/view/2fa6cb07
  1. using System;
  2. using System.Data;
  3. using System.Configuration;
  4. using System.Text;
  5. using System.CodeDom.Compiler;
  6. using Microsoft.CSharp;
  7. using System.Reflection;
  8.  
  9. namespace SSEC.Math
  10. {
  11.     /// <summary>  
  12.     /// 本类用来将字符串转为可执行文本并执行  
  13.     /// </summary>  
  14.     public class MyEvaluator
  15.     {
  16.         #region 构造函数
  17.  
  18.         /// <summary>  
  19.         /// 可执行串的构造函数  
  20.         /// </summary>  
  21.         /// <param name="items">  
  22.         /// 可执行字符串数组  
  23.         /// </param>  
  24.         public MyEvaluator(EvaluatorItem[] items)
  25.         {
  26.             ConstructEvaluator(items);      //调用解析字符串构造函数进行解析  
  27.         }
  28.  
  29.         /// <summary>  
  30.         /// 可执行串的构造函数  
  31.         /// </summary>  
  32.         /// <param name="returnType">返回值类型</param>  
  33.         /// <param name="expression">执行表达式</param>  
  34.         /// <param name="name">执行字符串名称</param>  
  35.         public MyEvaluator(Type returnType, string expression, string name)
  36.         {
  37.             //创建可执行字符串数组  
  38.             EvaluatorItem[] items = { new EvaluatorItem(returnType, expression, name) };
  39.             ConstructEvaluator(items);      //调用解析字符串构造函数进行解析  
  40.         }
  41.  
  42.         /// <summary>  
  43.         /// 可执行串的构造函数  
  44.         /// </summary>  
  45.         /// <param name="item">可执行字符串项</param>  
  46.         public MyEvaluator(EvaluatorItem item)
  47.         {
  48.             EvaluatorItem[] items = { item };//将可执行字符串项转为可执行字符串项数组  
  49.             ConstructEvaluator(items);      //调用解析字符串构造函数进行解析  
  50.         }
  51.  
  52.         /// <summary>  
  53.         /// 解析字符串构造函数  
  54.         /// </summary>  
  55.         /// <param name="items">待解析字符串数组</param>  
  56.         private void ConstructEvaluator(EvaluatorItem[] items)
  57.         {
  58.             //创建C#编译器实例
  59.             CodeDomProvider provider = CodeDomProvider.CreateProvider("C#");
  60.            
  61.             //过时了
  62.             //ICodeCompiler comp = provider.CreateCompiler();
  63.            
  64.             //编译器的传入参数  
  65.             CompilerParameters cp = new CompilerParameters();
  66.             cp.ReferencedAssemblies.Add("system.dll");              //添加程序集 system.dll 的引用  
  67.             cp.ReferencedAssemblies.Add("system.data.dll");         //添加程序集 system.data.dll 的引用  
  68.             cp.ReferencedAssemblies.Add("system.xml.dll");          //添加程序集 system.xml.dll 的引用  
  69.             cp.GenerateExecutable = false;                          //不生成可执行文件  
  70.             cp.GenerateInMemory = true;                             //在内存中运行  
  71.  
  72.             StringBuilder code = new StringBuilder();               //创建代码串  
  73.             /*  
  74.              *  添加常见且必须的引用字符串  
  75.              */
  76.             code.Append("using System; /n");
  77.             code.Append("using System.Data; /n");
  78.             code.Append("using System.Data.SqlClient; /n");
  79.             code.Append("using System.Data.OleDb; /n");
  80.             code.Append("using System.Xml; /n");
  81.  
  82.             code.Append("namespace SSEC.Math { /n");                  //生成代码的命名空间为EvalGuy，和本代码一样  
  83.  
  84.             code.Append("  public class _Evaluator { /n");          //产生 _Evaluator 类，所有可执行代码均在此类中运行  
  85.             foreach (EvaluatorItem item in items)               //遍历每一个可执行字符串项  
  86.             {
  87.                 code.AppendFormat("    public {0} {1}() ",          //添加定义公共函数代码  
  88.                                   item.ReturnType.Name,             //函数返回值为可执行字符串项中定义的返回值类型  
  89.                                   item.Name);                       //函数名称为可执行字符串项中定义的执行字符串名称  
  90.                 code.Append("{ ");                                  //添加函数开始括号  
  91.                 code.AppendFormat("return ({0});", item.Expression);//添加函数体，返回可执行字符串项中定义的表达式的值  
  92.                 code.Append("}/n");                                 //添加函数结束括号  
  93.             }
  94.             code.Append("} }");                                 //添加类结束和命名空间结束括号  
  95.  
  96.             //得到编译器实例的返回结果  
  97.             CompilerResults cr = provider.CompileAssemblyFromSource(cp, code.ToString());//comp
  98.  
  99.             if (cr.Errors.HasErrors)                            //如果有错误  
  100.             {
  101.                 StringBuilder error = new StringBuilder();          //创建错误信息字符串  
  102.                 error.Append("编译有错误的表达式: ");                //添加错误文本  
  103.                 foreach (CompilerError err in cr.Errors)            //遍历每一个出现的编译错误  
  104.                 {
  105.                     error.AppendFormat("{0}/n", err.ErrorText);     //添加进错误文本，每个错误后换行  
  106.                 }
  107.                 throw new Exception("编译错误: " + error.ToString());//抛出异常  
  108.             }
  109.             Assembly a = cr.CompiledAssembly;                       //获取编译器实例的程序集  
  110.             _Compiled = a.CreateInstance("SSEC.Math._Evaluator");     //通过程序集查找并声明 SSEC.Math._Evaluator 的实例  
  111.         }
  112.         #endregion
  113.  
  114.         #region 公有成员
  115.         /// <summary>  
  116.         /// 执行字符串并返回整型值  
  117.         /// </summary>  
  118.         /// <param name="name">执行字符串名称</param>  
  119.         /// <returns>执行结果</returns>  
  120.         public int EvaluateInt(string name)
  121.         {
  122.             return (int)Evaluate(name);
  123.         }
  124.         /// <summary>  
  125.         /// 执行字符串并返回双精度值  
  126.         /// </summary>  
  127.         /// <param name="name">执行字符串名称</param>  
  128.         /// <returns>执行结果</returns>  
  129.         public double EvaluateDouble(string name)
  130.         {
  131.             return (double)Evaluate(name);
  132.         }
  133.         /// <summary>  
  134.         /// 执行字符串并返回长整型数值  
  135.         /// </summary>  
  136.         /// <param name="name">执行字符串名称</param>  
  137.         /// <returns>执行结果</returns>  
  138.         public long EvaluateLong(string name)
  139.         {
  140.             return (long)Evaluate(name);
  141.         }
  142.         /// <summary>  
  143.         /// 执行字符串并返回十进制数值  
  144.         /// </summary>  
  145.         /// <param name="name">执行字符串名称</param>  
  146.         /// <returns>执行结果</returns>  
  147.         public decimal EvaluateDecimal(string name)
  148.         {
  149.             return (decimal)Evaluate(name);
  150.         }
  151.         /// <summary>  
  152.         /// 执行字符串并返回字符串型值  
  153.         /// </summary>  
  154.         /// <param name="name">执行字符串名称</param>  
  155.         /// <returns>执行结果</returns>  
  156.         public string EvaluateString(string name)
  157.         {
  158.             return (string)Evaluate(name);
  159.         }
  160.         /// <summary>  
  161.         /// 执行字符串并返回布尔型值  
  162.         /// </summary>  
  163.         /// <param name="name">执行字符串名称</param>  
  164.         /// <returns>执行结果</returns>  
  165.         public bool EvaluateBool(string name)
  166.         {
  167.             return (bool)Evaluate(name);
  168.         }
  169.         /// <summary>  
  170.         /// 执行字符串并返 object 型值  
  171.         /// </summary>  
  172.         /// <param name="name">执行字符串名称</param>  
  173.         /// <returns>执行结果</returns>  
  174.         public object Evaluate(string name)
  175.         {
  176.             MethodInfo mi = _Compiled.GetType().GetMethod(name);//获取 _Compiled 所属类型中名称为 name 的方法的引用  
  177.             return mi.Invoke(_Compiled, null);                  //执行 mi 所引用的方法  
  178.         }
  179.         #endregion
  180.  
  181.         #region 静态成员
  182.         /// <summary>  
  183.         /// 执行表达式并返回整型值  
  184.         /// </summary>  
  185.         /// <param name="code">要执行的表达式</param>  
  186.         /// <returns>运算结果</returns>  
  187.         static public int EvaluateToInteger(string code)
  188.         {
  189.             MyEvaluator eval = new MyEvaluator(typeof(int), code, staticMethodName);//生成 Evaluator 类的对像  
  190.             return (int)eval.Evaluate(staticMethodName);                        //执行并返回整型数据  
  191.         }
  192.         /// <summary>  
  193.         /// 执行表达式并返回双精度值  
  194.         /// </summary>  
  195.         /// <param name="name">执行字符串名称</param>  
  196.         /// <returns>执行结果</returns>  
  197.         static public double EvaluateToDouble(string code)
  198.         {
  199.             MyEvaluator eval = new MyEvaluator(typeof(double), code, staticMethodName);//生成 Evaluator 类的对像  
  200.             return (double)eval.Evaluate(staticMethodName);
  201.         }
  202.         /// <summary>  
  203.         /// 执行表达式并返回长整型数值  
  204.         /// </summary>  
  205.         /// <param name="name">执行字符串名称</param>  
  206.         /// <returns>执行结果</returns>  
  207.         static public long EvaluateToLong(string code)
  208.         {
  209.             MyEvaluator eval = new MyEvaluator(typeof(long), code, staticMethodName);//生成 Evaluator 类的对像  
  210.             return (long)eval.Evaluate(staticMethodName);
  211.         }
  212.         /// <summary>  
  213.         /// 执行表达式并返回十进制数值  
  214.         /// </summary>  
  215.         /// <param name="name">执行字符串名称</param>  
  216.         /// <returns>执行结果</returns>  
  217.         static public decimal EvaluateToDecimal(string code)
  218.         {
  219.             MyEvaluator eval = new MyEvaluator(typeof(decimal), code, staticMethodName);//生成 Evaluator 类的对像  
  220.             return (decimal)eval.Evaluate(staticMethodName);
  221.         }
  222.         /// <summary>  
  223.         /// 执行表达式并返回字符串型值  
  224.         /// </summary>  
  225.         /// <param name="code">要执行的表达式</param>  
  226.         /// <returns>运算结果</returns>  
  227.         static public string EvaluateToString(string code)
  228.         {
  229.             MyEvaluator eval = new MyEvaluator(typeof(string), code, staticMethodName);//生成 Evaluator 类的对像  
  230.             return (string)eval.Evaluate(staticMethodName);                     //执行并返回字符串型数据  
  231.         }
  232.         /// <summary>  
  233.         /// 执行表达式并返回布尔型值  
  234.         /// </summary>  
  235.         /// <param name="code">要执行的表达式</param>  
  236.         /// <returns>运算结果</returns>  
  237.         static public bool EvaluateToBool(string code)
  238.         {
  239.             MyEvaluator eval = new MyEvaluator(typeof(bool), code, staticMethodName);//生成 Evaluator 类的对像  
  240.             return (bool)eval.Evaluate(staticMethodName);                       //执行并返回布尔型数据  
  241.         }
  242.         /// <summary>  
  243.         /// 执行表达式并返回 object 型值  
  244.         /// </summary>  
  245.         /// <param name="code">要执行的表达式</param>  
  246.         /// <returns>运算结果</returns>  
  247.         static public object EvaluateToObject(string code)
  248.         {
  249.             MyEvaluator eval = new MyEvaluator(typeof(object), code, staticMethodName);//生成 Evaluator 类的对像  
  250.             return eval.Evaluate(staticMethodName);                             //执行并返回 object 型数据  
  251.         }
  252.         #endregion
  253.  
  254.         #region 私有成员
  255.         /// <summary>  
  256.         /// 静态方法的执行字符串名称  
  257.         /// </summary>  
  258.         private const string staticMethodName = "__foo";
  259.         /// <summary>  
  260.         /// 用于动态引用生成的类，执行其内部包含的可执行字符串  
  261.         /// </summary>  
  262.         object _Compiled = null;
  263.         #endregion
  264.     }
  265.  
  266.  
  267.     /// <summary>  
  268.     /// 可执行字符串项（即一条可执行字符串）  
  269.     /// </summary>  
  270.     public class EvaluatorItem
  271.     {
  272.         /// <summary>  
  273.         /// 返回值类型  
  274.         /// </summary>  
  275.         public Type ReturnType;
  276.         /// <summary>  
  277.         /// 执行表达式  
  278.         /// </summary>  
  279.         public string Expression;
  280.         /// <summary>  
  281.         /// 执行字符串名称  
  282.         /// </summary>  
  283.         public string Name;
  284.         /// <summary>  
  285.         /// 可执行字符串项构造函数  
  286.         /// </summary>  
  287.         /// <param name="returnType">返回值类型</param>  
  288.         /// <param name="expression">执行表达式</param>  
  289.         /// <param name="name">执行字符串名称</param>  
  290.         public EvaluatorItem(Type returnType, string expression, string name)
  291.         {
  292.             ReturnType = returnType;
  293.             Expression = expression;
  294.             Name = name;
  295.         }
  296.     }
  297. }
  298.  
  299.  
  300. //csharp/7130

回复 "C#执行字符串参数的运算表达式"

这儿你可以回复上面这条便签

captcha

贴代码片段 - Code666