转：将字符串或表达式直接转为C#可执行代码的办法

原文地址：http://blog.csdn.net/qwlovedzm/article/details/6292147

近日有个项目有不少的计算公式，而且要求能定制，如何能将字符串或表达式直接转为C#的可执行代码就好了。

经过从网上查阅资料，发现有一个开源的工具类，将它修改后改为如下效果：

 

[c-sharp] view plaincopyprint?
  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.     publicclass 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.         privatevoid 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.                 thrownew Exception("编译错误: " + error.ToString());//抛出异常    
  108.             } 
  109.             Assembly a = cr.CompiledAssembly;                       //获取编译器实例的程序集    
  110.             _Compiled = a.CreateInstance("SSEC.Math._Evaluator");     //通过程序集查找并声明 SSEC.Math._Evaluator 的实例    
  111.         } 
  112.         #endregion 
  114.         #region 公有成员 
  115.         /// <summary>    
  116.         /// 执行字符串并返回整型值    
  117.         /// </summary>    
  118.         /// <param name="name">执行字符串名称</param>    
  119.         /// <returns>执行结果</returns>    
  120.         publicint EvaluateInt(string name) 
  121.         { 
  122.             return (int)Evaluate(name); 
  123.         } 
  124.         /// <summary>    
  125.         /// 执行字符串并返回双精度值    
  126.         /// </summary>    
  127.         /// <param name="name">执行字符串名称</param>    
  128.         /// <returns>执行结果</returns>    
  129.         publicdouble EvaluateDouble(string name) 
  130.         { 
  131.             return (double)Evaluate(name); 
  132.         } 
  133.         /// <summary>    
  134.         /// 执行字符串并返回长整型数值    
  135.         /// </summary>    
  136.         /// <param name="name">执行字符串名称</param>    
  137.         /// <returns>执行结果</returns>    
  138.         publiclong EvaluateLong(string name) 
  139.         { 
  140.             return (long)Evaluate(name); 
  141.         } 
  142.         /// <summary>    
  143.         /// 执行字符串并返回十进制数值    
  144.         /// </summary>    
  145.         /// <param name="name">执行字符串名称</param>    
  146.         /// <returns>执行结果</returns>    
  147.         publicdecimal EvaluateDecimal(string name) 
  148.         { 
  149.             return (decimal)Evaluate(name); 
  150.         } 
  151.         /// <summary>    
  152.         /// 执行字符串并返回字符串型值    
  153.         /// </summary>    
  154.         /// <param name="name">执行字符串名称</param>    
  155.         /// <returns>执行结果</returns>    
  156.         publicstring EvaluateString(string name) 
  157.         { 
  158.             return (string)Evaluate(name); 
  159.         } 
  160.         /// <summary>    
  161.         /// 执行字符串并返回布尔型值    
  162.         /// </summary>    
  163.         /// <param name="name">执行字符串名称</param>    
  164.         /// <returns>执行结果</returns>    
  165.         publicbool 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.         publicobject Evaluate(string name) 
  175.         { 
  176.             MethodInfo mi = _Compiled.GetType().GetMethod(name);//获取 _Compiled 所属类型中名称为 name 的方法的引用    
  177.             return mi.Invoke(_Compiled, null);                  //执行 mi 所引用的方法    
  178.         } 
  179.         #endregion 
  181.         #region 静态成员 
  182.         /// <summary>    
  183.         /// 执行表达式并返回整型值    
  184.         /// </summary>    
  185.         /// <param name="code">要执行的表达式</param>    
  186.         /// <returns>运算结果</returns>    
  187.         staticpublicint 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.         staticpublicdouble 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.         staticpubliclong 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.         staticpublicdecimal 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.         staticpublicstring 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.         staticpublicbool 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.         staticpublicobject EvaluateToObject(string code) 
  248.         { 
  249.             MyEvaluator eval = new MyEvaluator(typeof(object), code, staticMethodName);//生成 Evaluator 类的对像    
  250.             return eval.Evaluate(staticMethodName);                             //执行并返回 object 型数据    
  251.         } 
  252.         #endregion 
  254.         #region 私有成员 
  255.         /// <summary>    
  256.         /// 静态方法的执行字符串名称    
  257.         /// </summary>    
  258.         privateconststring staticMethodName = "__foo"; 
  259.         /// <summary>    
  260.         /// 用于动态引用生成的类，执行其内部包含的可执行字符串    
  261.         /// </summary>    
  262.         object _Compiled = null; 
  263.         #endregion 
  264.     } 
  265.  
  266.  
  267.     /// <summary>    
  268.     /// 可执行字符串项（即一条可执行字符串）    
  269.     /// </summary>    
  270.     publicclass EvaluatorItem 
  271.     { 
  272.         /// <summary>    
  273.         /// 返回值类型    
  274.         /// </summary>    
  275.         public Type ReturnType; 
  276.         /// <summary>    
  277.         /// 执行表达式    
  278.         /// </summary>    
  279.         publicstring Expression; 
  280.         /// <summary>    
  281.         /// 执行字符串名称    
  282.         /// </summary>    
  283.         publicstring 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. } 

 

 

下面是测试类：

[c-sharp] view plaincopyprint?
  1. class Test 
  2.     { 
  3.         /// <summary> 
  4.         /// The main entry point for the application. 
  5.         /// </summary> 
  6.         [STAThread] 
  7.         staticvoid Main(string[] args) 
  8.         { 
  9.             Console.WriteLine("Test0: {0}", MyEvaluator.EvaluateToInteger("(30 + 4) * 2")); 
  10.             Console.WriteLine("Test1: {0}", MyEvaluator.EvaluateToString("/"Hello /" + /"There/"")); 
  11.             Console.WriteLine("Test2: {0}", MyEvaluator.EvaluateToBool("30 == 40")); 
  12.             Console.WriteLine("Test3: {0}", MyEvaluator.EvaluateToObject("new DataSet()")); 
  13.             Console.WriteLine("Test4: {0}", MyEvaluator.EvaluateToDouble("(12.4+2.2)*0.4")); 
  14.             Console.WriteLine("Test5: {0}", MyEvaluator.EvaluateToLong("(12+1000)*1000")); 
  15.             Console.WriteLine("Test6: {0}", MyEvaluator.EvaluateToString("/"double max==/"+double.MaxValue"));//decimal.MaxValue+/",/"+ 
  16.              
  17.  
  18.             EvaluatorItem[] items = { 
  19.                                     new EvaluatorItem(typeof(int), "(30 + 4) * 2", "GetNumber"), 
  20.                                     new EvaluatorItem(typeof(string), "/"Hello /" + /"There/"", "GetString"), 
  21.                                     new EvaluatorItem(typeof(bool), "30 == 40", "GetBool"), 
  22.                                     new EvaluatorItem(typeof(object), "new DataSet()", "GetDataSet") 
  23.                                     }; 
  24.  
  25.             MyEvaluator eval = new MyEvaluator(items); 
  26.             Console.WriteLine("TestStatic0: {0}", eval.EvaluateInt("GetNumber")); 
  27.             Console.WriteLine("TestStatic1: {0}", eval.EvaluateString("GetString")); 
  28.             Console.WriteLine("TestStatic2: {0}", eval.EvaluateBool("GetBool")); 
  29.             Console.WriteLine("TestStatic3: {0}", eval.Evaluate("GetDataSet")); 
  30.             Console.ReadLine(); 
  31.         } 
  32.     } 

 

 

经测试，想要的结果终于出来了。

posted @ 2013-04-27 17:27  wadeheng  阅读(1268)  评论(0)  编辑  收藏  举报