C#动态执行代码

在开始之前，先熟悉几个类及部分属性、方法：CSharpCodeProvider、ICodeCompiler、CompilerParameters、CompilerResults、Assembly。

　　一、CSharpCodeProvider
　　　　提供对C#代码生成器和代码编译器的实例的访问。如果要动态生成VB代码，可以使用VBCodeProvider。

　　　　CreateCompiler()：获取编译器的实例。

　　二、ICodeCompiler
　　　　定义用于调用源代码编译的接口或使用指定编译器的CodeDOM树。每种编译方法都接受指示编译器的CompilerParameters对象，并返回指示编译结果的CompilerResults对象。

　　　　CompilerAssemblyFromSource(CompilerParameters option, string source)：使用指定的编译器，从包含源代码的字符串设置编译程序集。

　　三、CompilerParameters
　　　　表示用于调用编译器的参数。

　　　　ReferencedAssemblies：获取当前项目所引用的程序集。Add方法为程序集添加引用。
　　　　GenerateExecutable：获取或设置一个值，该值指示是否生成可执行文件。若此属性为false，则生成DLL，默认是false。
　　　　GenerateInMemory：获取或设置一个值，该值指示是否在内存中生成输出。

　　四、CompilerResults
　　　　表示从编译器返回的编译结果。

　　　　CompiledAssembly：获取或设置以编译的程序集，Assembly类型。

　　五、Assembly
　　　　就是程序集了（不知道如何描述了）。

　　大致了解了以上知识之后，就可以使用C#动态的编译并执行代码了，一下是一段示例程序：

using System;
using System.Reflection;
using System.Globalization;
using Microsoft.CSharp;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Text;

namespace ConsoleApplication1
{
    publicclass Program
      {
        staticvoid Main(string[] args)
          {
            // 1.CSharpCodePrivoder
              CSharpCodeProvider objCSharpCodePrivoder =new CSharpCodeProvider();

            // 2.ICodeComplier
              ICodeCompiler objICodeCompiler = objCSharpCodePrivoder.CreateCompiler();

            // 3.CompilerParameters
              CompilerParameters objCompilerParameters =new CompilerParameters();
              objCompilerParameters.ReferencedAssemblies.Add("System.dll");
              objCompilerParameters.GenerateExecutable =false;
              objCompilerParameters.GenerateInMemory =true;

            // 4.CompilerResults
              CompilerResults cr = objICodeCompiler.CompileAssemblyFromSource(objCompilerParameters, GenerateCode());

            if (cr.Errors.HasErrors)
              {
                  Console.WriteLine("编译错误：");
                foreach (CompilerError err in cr.Errors)
                  {
                      Console.WriteLine(err.ErrorText);
                  }
              }
            else
              {
                // 通过反射，调用HelloWorld的实例
                  Assembly objAssembly = cr.CompiledAssembly;
                object objHelloWorld = objAssembly.CreateInstance("DynamicCodeGenerate.HelloWorld");
                  MethodInfo objMI = objHelloWorld.GetType().GetMethod("OutPut");

                  Console.WriteLine(objMI.Invoke(objHelloWorld, null));
              }

              Console.ReadLine();
          }

        staticstring GenerateCode()
          {
              StringBuilder sb =new StringBuilder();
              sb.Append("using System;");
              sb.Append(Environment.NewLine);
              sb.Append("namespace DynamicCodeGenerate");
              sb.Append(Environment.NewLine);
              sb.Append("{");
              sb.Append(Environment.NewLine);
              sb.Append("      public class HelloWorld");
              sb.Append(Environment.NewLine);
              sb.Append("      {");
              sb.Append(Environment.NewLine);
              sb.Append("          public string OutPut()");
              sb.Append(Environment.NewLine);
              sb.Append("          {");
              sb.Append(Environment.NewLine);
              sb.Append("               return \"Hello world!\";");
              sb.Append(Environment.NewLine);
              sb.Append("          }");
              sb.Append(Environment.NewLine);
              sb.Append("      }");
              sb.Append(Environment.NewLine);
              sb.Append("}");

            string code = sb.ToString();
              Console.WriteLine(code);
              Console.WriteLine();

            return code;
          }
      }
}

出处：http://www.cnblogs.com/wenjl520/archive/2008/12/31/1365968.html

=======================================================================================

c#动态执行字符串脚本（优化版）

像javascript中有eval()来执行动态代码，c#中是没有的，于是自己动手丰衣足食，

先来代码

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

View Code

调用一个无返回值的代码，显示一个提示框

Evaluator.EvaluateToVoid("MessageBox.Show(\"Test\");",new Dictionary<string, string>() { { "System.Windows.Forms.dll", "System.Windows.Forms" } });

调用一个计算返回整型

            Evaluator.EvaluateToInteger("1+2*3");

调用一个全代码

            string str = @"using System;
namespace a
{ 
    public class b
    {
        public  void c()
        {
            Console.WriteLine(1);
        }
    }
}";

Evaluator.EvaluateByAllCode(str, "a", "b", "c");

功能就这么多

出处：https://www.cnblogs.com/bfyx/p/17261116.html

posted on 2017-06-15 14:22 jack_Meng 阅读(8217) 评论(0) 编辑收藏举报

刷新页面返回顶部

Jack_孟

C#动态执行代码

c#动态执行字符串脚本（优化版）

导航

公告