C#动态执行字符串(动态创建代码)的实例代码

namespaceEvalGuy
{
   ///<summary>
   ///本类用来将字符串转为可执行文本并执行
   ///从别处复制，勿随意更改！
   ///</summary>
   publicclassEvaluator
   {
       #region构造函数
       ///<summary>
       ///可执行串的构造函数
       ///</summary>
       ///<paramname="items">
       ///可执行字符串数组
       ///</param>
       publicEvaluator(EvaluatorItem[]items)
       {
           ConstructEvaluator(items);       //调用解析字符串构造函数进行解析
       }
       ///<summary>
       ///可执行串的构造函数
       ///</summary>
       ///<paramname="returnType">返回值类型</param>
       ///<paramname="expression">执行表达式</param>
       ///<paramname="name">执行字符串名称</param>
       publicEvaluator(TypereturnType,stringexpression,stringname)
       {
           //创建可执行字符串数组
           EvaluatorItem[]items={newEvaluatorItem(returnType,expression,name)};
           ConstructEvaluator(items);       //调用解析字符串构造函数进行解析
       }
       ///<summary>
       ///可执行串的构造函数
       ///</summary>
       ///<paramname="item">可执行字符串项</param>
       publicEvaluator(EvaluatorItemitem)
       {
           EvaluatorItem[]items={item};//将可执行字符串项转为可执行字符串项数组
           ConstructEvaluator(items);       //调用解析字符串构造函数进行解析
       }
       ///<summary>
       ///解析字符串构造函数
       ///</summary>
       ///<paramname="items">待解析字符串数组</param>
       privatevoidConstructEvaluator(EvaluatorItem[]items)
       {
           //创建C#编译器实例
           ICodeCompilercomp=(newCSharpCodeProvider().CreateCompiler());
           //编译器的传入参数
           CompilerParameterscp=newCompilerParameters();

           cp.ReferencedAssemblies.Add("system.dll");               //添加程序集system.dll的引用
           cp.ReferencedAssemblies.Add("system.data.dll");           //添加程序集system.data.dll的引用
           cp.ReferencedAssemblies.Add("system.xml.dll");           //添加程序集system.xml.dll的引用
           cp.GenerateExecutable=false;                           //不生成可执行文件
           cp.GenerateInMemory=true;                               //在内存中运行

           StringBuildercode=newStringBuilder();               //创建代码串
           /*
            * 添加常见且必须的引用字符串
            */
           code.Append("usingSystem;/n");
           code.Append("usingSystem.Data;/n");
           code.Append("usingSystem.Data.SqlClient;/n");
           code.Append("usingSystem.Data.OleDb;/n");
           code.Append("usingSystem.Xml;/n");

           code.Append("namespaceEvalGuy{/n");                   //生成代码的命名空间为EvalGuy，和本代码一样

           code.Append(" publicclass_Evaluator{/n");           //产生_Evaluator类，所有可执行代码均在此类中运行
           foreach(EvaluatorItemiteminitems)               //遍历每一个可执行字符串项
           {
               code.AppendFormat("   public{0}{1}()",           //添加定义公共函数代码
                                 item.ReturnType.Name,               //函数返回值为可执行字符串项中定义的返回值类型
                                 item.Name);                       //函数名称为可执行字符串项中定义的执行字符串名称
               code.Append("{");                                   //添加函数开始括号
               code.AppendFormat("return({0});",item.Expression);//添加函数体，返回可执行字符串项中定义的表达式的值
               code.Append("}/n");                                   //添加函数结束括号
           }
           code.Append("}}");                                   //添加类结束和命名空间结束括号

           //得到编译器实例的返回结果
           CompilerResultscr=comp.CompileAssemblyFromSource(cp,code.ToString());

           if(cr.Errors.HasErrors)                           //如果有错误
           {
               StringBuildererror=newStringBuilder();           //创建错误信息字符串
               error.Append("编译有错误的表达式:");               //添加错误文本
               foreach(CompilerErrorerrincr.Errors)           //遍历每一个出现的编译错误
               {
                   error.AppendFormat("{0}/n",err.ErrorText);       //添加进错误文本，每个错误后换行
               }
               thrownewException("编译错误:"+error.ToString());//抛出异常
           }
           Assemblya=cr.CompiledAssembly;                       //获取编译器实例的程序集
           _Compiled=a.CreateInstance("EvalGuy._Evaluator");       //通过程序集查找并声明EvalGuy._Evaluator的实例
       }
       #endregion

       #region公有成员
       ///<summary>
       ///执行字符串并返回整型值
       ///</summary>
       ///<paramname="name">执行字符串名称</param>
       ///<returns>执行结果</returns>
       publicintEvaluateInt(stringname)
       {
           return(int)Evaluate(name);
       }
       ///<summary>
       ///执行字符串并返回字符串型值
       ///</summary>
       ///<paramname="name">执行字符串名称</param>
       ///<returns>执行结果</returns>
       publicstringEvaluateString(stringname)
       {
           return(string)Evaluate(name);
       }
       ///<summary>
       ///执行字符串并返回布尔型值
       ///</summary>
       ///<paramname="name">执行字符串名称</param>
       ///<returns>执行结果</returns>
       publicboolEvaluateBool(stringname)
       {
           return(bool)Evaluate(name);
       }
       ///<summary>
       ///执行字符串并返object型值
       ///</summary>
       ///<paramname="name">执行字符串名称</param>
       ///<returns>执行结果</returns>
       publicobjectEvaluate(stringname)
       {
           MethodInfomi=_Compiled.GetType().GetMethod(name);//获取_Compiled所属类型中名称为name的方法的引用
           returnmi.Invoke(_Compiled,null);                   //执行mi所引用的方法
       }
       #endregion

       #region静态成员
       ///<summary>
       ///执行表达式并返回整型值
       ///</summary>
       ///<paramname="code">要执行的表达式</param>
       ///<returns>运算结果</returns>
       staticpublicintEvaluateToInteger(stringcode)
       {
           Evaluatoreval=newEvaluator(typeof(int),code,staticMethodName);//生成Evaluator类的对像
           return(int)eval.Evaluate(staticMethodName);                       //执行并返回整型数据
       }
       ///<summary>
       ///执行表达式并返回字符串型值
       ///</summary>
       ///<paramname="code">要执行的表达式</param>
       ///<returns>运算结果</returns>
       staticpublicstringEvaluateToString(stringcode)
       {
           Evaluatoreval=newEvaluator(typeof(string),code,staticMethodName);//生成Evaluator类的对像
           return(string)eval.Evaluate(staticMethodName);                       //执行并返回字符串型数据
       }
       ///<summary>
       ///执行表达式并返回布尔型值
       ///</summary>
       ///<paramname="code">要执行的表达式</param>
       ///<returns>运算结果</returns>
       staticpublicboolEvaluateToBool(stringcode)
       {
           Evaluatoreval=newEvaluator(typeof(bool),code,staticMethodName);//生成Evaluator类的对像
           return(bool)eval.Evaluate(staticMethodName);                       //执行并返回布尔型数据
       }
       ///<summary>
       ///执行表达式并返回object型值
       ///</summary>
       ///<paramname="code">要执行的表达式</param>
       ///<returns>运算结果</returns>
       staticpublicobjectEvaluateToObject(stringcode)
       {
           Evaluatoreval=newEvaluator(typeof(object),code,staticMethodName);//生成Evaluator类的对像
           returneval.Evaluate(staticMethodName);                               //执行并返回object型数据
       }
       #endregion

       #region私有成员
       ///<summary>
       ///静态方法的执行字符串名称
       ///</summary>
       privateconststringstaticMethodName="__foo";
       ///<summary>
       ///用于动态引用生成的类，执行其内部包含的可执行字符串
       ///</summary>
       object_Compiled=null;
       #endregion
   }
   ///<summary>
   ///可执行字符串项（即一条可执行字符串）
   ///</summary>
   publicclassEvaluatorItem
   {
       ///<summary>
       ///返回值类型
       ///</summary>
       publicTypeReturnType;
       ///<summary>
       ///执行表达式
       ///</summary>
       publicstringExpression;
       ///<summary>
       ///执行字符串名称
       ///</summary>
       publicstringName;
       ///<summary>
       ///可执行字符串项构造函数
       ///</summary>
       ///<paramname="returnType">返回值类型</param>
       ///<paramname="expression">执行表达式</param>
       ///<paramname="name">执行字符串名称</param>
       publicEvaluatorItem(TypereturnType,stringexpression,stringname)
       {
           ReturnType=returnType;
           Expression=expression;
           Name=name;
       }
   }
}