C#如何实现动态执行字符串脚本

其他教程   发布日期:2024年04月22日   浏览次数:275

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

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

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

调用一个计算返回整型

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

调用一个全代码

  1. string str = @"using System;
  2. namespace a
  3. {
  4. public class b
  5. {
  6. public void c()
  7. {
  8. Console.WriteLine(1);
  9. }
  10. }
  11. }";
  12. Evaluator.EvaluateByAllCode(str, "a", "b", "c");

功能就这么多

以上就是C#如何实现动态执行字符串脚本的详细内容,更多关于C#如何实现动态执行字符串脚本的资料请关注九品源码其它相关文章!