zoukankan      html  css  js  c++  java

  • 转：将字符串或表达式直接转为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.     } 

    经测试，想要的结果终于出来了。
  • 相关阅读:
    全网最详细的Linux命令系列-ls命令
    Kubernetes 部署策略详解-转载学习
    Kubernetes工作流程--<1>
    详解CURL状态码，最全的代码列表
    Haproxy-4层和7层代理负载实战
    Keepalived+Nginx高可用实例
    实现FTP+PAM+MySQL环境，批量配置虚拟用户
    每秒处理10万订单乐视集团支付Mysql架构-转载
    构建 CDN 分发网络架构简析
    Linux系统入门简介<1>
  • 原文地址：https://www.cnblogs.com/wadeheng/p/3047558.html
Copyright © 2011-2022 走看看