重新演绎动态编译类，打造灵活多变的系统

前端时间，写过一篇博文：《 C#动态编译，实现按钮功能动态配置》，里面提到了动态编译的好处，可以随时添加你要集成的功能，而不用去重新启动系统。如果系统超级大，启动需要半个小时甚至数个小时的话，用动态编译是极佳的选择。

 

动态编译的好处让我舍不得丢弃它，所以只好找方法来优化它了。既然每次点击需要编译，如果我把全部功能都一次性编译完毕，保存这个实例，然后每次点击，都通过这个实例去调用对应的方法，这样就完美解决了这一问题。 

 

不多说，上代码：

动态编译类 Evaluator：

View Code

  1 using System;
  2 using System.IO;
  3 using System.Text;
  4 using System.CodeDom.Compiler;
  5 using System.Windows.Forms;
  6 using Microsoft.CSharp;
  7 using System.Reflection;
  8 
  9 namespace CashierSystem
 10 {
 11     /// <summary>   
 12     /// 本类用来将字符串转为可执行文本并执行，用于动态定义按钮响应的事件。
 13     /// </summary>   
 14     public class Evaluator
 15     {
 16         private string filepath = Path.Combine(Application.StartupPath, "FunBtn.config");
 17      
 18         #region 构造函数
 19         /// <summary>   
 20         /// 可执行串的构造函数   
 21         /// </summary>   
 22         /// <param name="items">可执行字符串数组</param>   
 23         public Evaluator(EvaluatorItem[] items)
 24         {
 25             ConstructEvaluator(items);      //调用解析字符串构造函数进行解析   
 26         }
 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)
 35         {
 36             //创建可执行字符串数组   
 37             EvaluatorItem[] items = { new EvaluatorItem(returnType, expression, name)  };
 38             ConstructEvaluator(items);      //调用解析字符串构造函数进行解析
 39         }
 40 
 41         /// <summary>   
 42         /// 可执行串的构造函数   
 43         /// </summary>   
 44         /// <param name="item">可执行字符串项</param>   
 45         public Evaluator(EvaluatorItem item)
 46         {
 47             EvaluatorItem[] items = { item };//将可执行字符串项转为可执行字符串项数组   
 48             ConstructEvaluator(items);      //调用解析字符串构造函数进行解析   
 49         }
 50 
 51         /// <summary>   
 52         /// 解析字符串构造函数   
 53         /// </summary>   
 54         /// <param name="items">待解析字符串数组</param>   
 55         private void ConstructEvaluator(EvaluatorItem[] items)
 56         {
 57             //创建C#编译器实例   
 58             //ICodeCompiler comp = (new CSharpCodeProvider().CreateCompiler());
 59             CSharpCodeProvider comp = new CSharpCodeProvider(); 
 60             //编译器的传入参数   
 61             CompilerParameters cp = new CompilerParameters();
 62 
 63             Configer configer = Configer.Current(filepath);
 64             string[] assemblies = configer.GetAssembly("FunBtn//assembly//dll","name");
 65             cp.ReferencedAssemblies.AddRange(assemblies);           //添加程序集集合
 66             
 67             cp.GenerateExecutable = false;                          //不生成可执行文件   
 68             cp.GenerateInMemory = true;                             //在内存中运行   
 69 
 70             StringBuilder code = new StringBuilder();               //创建代码串   
 71             /* 
 72              * 添加常见且必须的引用字符串 
 73              */
 74             //获取引用的命名空间
 75             string[] usings = configer.GetAssembly("FunBtn//assembly//using", "name");
 76 
 77             foreach (var @using in usings)
 78             {
 79                 code.Append(@using+"\n");//添加引用的命名空间
 80             }
 81 
 82             code.Append("namespace EvalGuy { \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.ToLower() ,             //函数返回值为可执行字符串项中定义的返回值类型   
 89                                   item.Name);                       //函数名称为可执行字符串项中定义的执行字符串名称   
 90                 code.Append("{ ");                                  //添加函数开始括号
 91                 if (item.ReturnType.Name == "Void")
 92                 {
 93                     code.AppendFormat("{0};", item.Expression);//添加函数体，返回可执行字符串项中定义的表达式的值   
 94                 }
 95                 else
 96                 {
 97                     code.AppendFormat("return ({0});", item.Expression);//添加函数体，返回可执行字符串项中定义的表达式的值   
 98                 }
 99                 code.Append("}\n");                                 //添加函数结束括号   
100             }
101             code.Append("} }");                                 //添加类结束和命名空间结束括号   
102 
103             //得到编译器实例的返回结果   
104             CompilerResults cr = comp.CompileAssemblyFromSource(cp, code.ToString());
105 
106             if (cr.Errors.HasErrors)                            //如果有错误   
107             {
108                 StringBuilder error = new StringBuilder();          //创建错误信息字符串   
109                 error.Append("编译有错误的表达式: ");                //添加错误文本   
110                 foreach (CompilerError err in cr.Errors)            //遍历每一个出现的编译错误   
111                 {
112                     error.AppendFormat("{0}\n", err.ErrorText);     //添加进错误文本，每个错误后换行   
113                 }
114                 throw new Exception("编译错误: " + error.ToString());//抛出异常   
115             }
116             Assembly a = cr.CompiledAssembly;                       //获取编译器实例的程序集   
117             _Compiled = a.CreateInstance("EvalGuy._Evaluator");     //通过程序集查找并声明 EvalGuy._Evaluator 的实例   
118         }
119         #endregion
120 
121         #region 公有成员
122         /// <summary>   
123         /// 执行字符串并返回整型值   
124         /// </summary>   
125         /// <param name="name">执行字符串名称</param>   
126         /// <returns>执行结果</returns>   
127         public int EvaluateInt(string name)
128         {
129             return (int)Evaluate(name);
130         }
131         /// <summary>   
132         /// 执行字符串并返回字符串型值   
133         /// </summary>   
134         /// <param name="name">执行字符串名称</param>   
135         /// <returns>执行结果</returns>   
136         public string EvaluateString(string name)
137         {
138             return (string)Evaluate(name);
139         }
140         /// <summary>   
141         /// 执行字符串并返回布尔型值   
142         /// </summary>   
143         /// <param name="name">执行字符串名称</param>   
144         /// <returns>执行结果</returns>   
145         public bool EvaluateBool(string name)
146         {
147             return (bool)Evaluate(name);
148         }
149         /// <summary>   
150         /// 执行字符串并返 object 型值   
151         /// </summary>   
152         /// <param name="name">执行字符串名称</param>   
153         /// <returns>执行结果</returns>   
154         public object Evaluate(string name)
155         {
156             MethodInfo mi = _Compiled.GetType().GetMethod(name);//获取 _Compiled 所属类型中名称为 name 的方法的引用   
157             return mi.Invoke(_Compiled, null);                  //执行 mi 所引用的方法   
158         }
159 
160         public void EvaluateVoid(string name)
161         {
162             MethodInfo mi = _Compiled.GetType().GetMethod(name);//获取 _Compiled 所属类型中名称为 name 的方法的引用   
163             mi.Invoke(_Compiled, null);                  //执行 mi 所引用的方法   
164         }
165 
166         #endregion
167 
168         #region 静态成员
169         /// <summary>   
170         /// 执行表达式并返回整型值   
171         /// </summary>   
172         /// <param name="code">要执行的表达式</param>   
173         /// <returns>运算结果</returns>   
174         static public int EvaluateToInteger(string code)
175         {
176             Evaluator eval = new Evaluator(typeof(int), code, staticMethodName);//生成 Evaluator 类的对像   
177             return (int)eval.Evaluate(staticMethodName);                        //执行并返回整型数据   
178         }
179         /// <summary>   
180         /// 执行表达式并返回字符串型值   
181         /// </summary>   
182         /// <param name="code">要执行的表达式</param>   
183         /// <returns>运算结果</returns>   
184         static public string EvaluateToString(string code)
185         {
186             Evaluator eval = new Evaluator(typeof(string), code, staticMethodName);//生成 Evaluator 类的对像   
187             return (string)eval.Evaluate(staticMethodName);                     //执行并返回字符串型数据   
188         }
189         /// <summary>   
190         /// 执行表达式并返回布尔型值   
191         /// </summary>   
192         /// <param name="code">要执行的表达式</param>   
193         /// <returns>运算结果</returns>   
194         static public bool EvaluateToBool(string code)
195         {
196             Evaluator eval = new Evaluator(typeof(bool), code, staticMethodName);//生成 Evaluator 类的对像   
197             return (bool)eval.Evaluate(staticMethodName);                       //执行并返回布尔型数据   
198         }
199         /// <summary>   
200         /// 执行表达式并返回 object 型值   
201         /// </summary>   
202         /// <param name="code">要执行的表达式</param>   
203         /// <returns>运算结果</returns>   
204         static public object EvaluateToObject(string code)
205         {
206             Evaluator eval = new Evaluator(typeof(object), code, staticMethodName);//生成 Evaluator 类的对像   
207             return eval.Evaluate(staticMethodName);                             //执行并返回 object 型数据   
208         }
209 
210         /// <summary>   
211         /// 执行表达式并返回 void 空值   
212         /// </summary>   
213         /// <param name="code">要执行的表达式</param>   
214         static public void EvaluateToVoid(string code)
215         {
216             Evaluator eval = new Evaluator(typeof(void), code, staticMethodName);//生成 Evaluator 类的对像   
217             eval.EvaluateVoid(staticMethodName);                             //执行并返回 object 型数据   
218         }
219 
220         #endregion
221 
222         #region 私有成员
223         /// <summary>   
224         /// 静态方法的执行字符串名称   
225         /// </summary>   
226         private const string staticMethodName = "ExecuteBtnCommand";
227         /// <summary>   
228         /// 用于动态引用生成的类，执行其内部包含的可执行字符串   
229         /// </summary>   
230         object _Compiled = null;
231         #endregion
232     }
233     /// <summary>   
234     /// 可执行字符串项（即一条可执行字符串）   
235     /// </summary>   
236     public class EvaluatorItem
237     {
238         /// <summary>   
239         /// 返回值类型   
240         /// </summary>   
241         public Type ReturnType;
242         /// <summary>   
243         /// 执行表达式   
244         /// </summary>   
245         public string Expression;
246         /// <summary>   
247         /// 执行字符串名称   
248         /// </summary>   
249         public string Name;
250         /// <summary>   
251         /// 可执行字符串项构造函数   
252         /// </summary>   
253         /// <param name="returnType">返回值类型</param>   
254         /// <param name="expression">执行表达式</param>   
255         /// <param name="name">执行字符串名称</param>   
256         public EvaluatorItem(Type returnType, string expression, string name)
257         {
258             ReturnType = returnType;
259             Expression = expression;
260             Name = name;
261         }
262     }
263 }

 

 

 

在调用的类中，声明一个动态编译类的实例

 

1         //配置文件路径名称
2         private string filePath = Path.Combine(Application.StartupPath, "FunBtn.config"); //文件路径
3 
4         //用于动态编译功能
5         private Evaluator eval = null;

 

 同时，要有一次性编译功能的方法

 

View Code

 1         /// <summary>
 2         /// 一次性编译所有按钮的功能
 3         /// </summary>
 4         public void CreateFun()
 5         {
 6             //创建配置类
 7             Configer configer = Configer.Current(filePath);
 8 
 9             //获取按钮名称，执行代码，返回值
10             string[] name = configer.GetNodeProperties("FunBtn//btndetail//btn", "name");
11             string[] code = configer.GetNodeProperties("FunBtn//btndetail//btn", "code");
12             string[] returnType = configer.GetNodeProperties("FunBtn//btndetail//btn", "returntype");
13 
14             //创建可执行字符串数组   
15             EvaluatorItem[] items = new EvaluatorItem[name.Length];
16             for (int i = 0; i < items.Length; i++)
17             {
18                 items[i] = new EvaluatorItem(GetTypeByString(returnType[i]), code[i], name[i]);
19             }
20 
21             //一次性初始化全部按钮
22             eval = new Evaluator(items);      //调用解析字符串构造函数进行解析
23 
24         }

 

动态配置，这个动态体现在使用配置文件上。所以配置文件和读写配置文件的类是不能省掉的：

 

读写配置文件类Configer:

 

View Code

  1 using System.Drawing;
  2 using System.IO;
  3 using System.Windows.Forms;
  4 using System.Xml;
  5 
  6 namespace CashierSystem
  7 {
  8     ///   <summary> 
  9     ///   负责读写应用程序配置文件，即app.config的读写。 
 10     ///   </summary> 
 11     public class Configer
 12     {
 13         #region   私有成员
 14 
 15         private string version; //版本号
 16         private string updatetime; //更新时间
 17         private string isautoupdate; //是否自动更新
 18         private string funbtnwidth; //功能区按钮宽度
 19         private string funbtnheight; //功能区按钮高度
 20         private string expandbtnwidth; //扩展区按钮宽度
 21         private string expandbtnheight; //扩展区按钮高度
 22 
 23         //private string btnname; //按钮名称
 24         //private string btntext; //按钮显示文本
 25         //private string btntype; //按钮类型
 26         //private string btnleft; //左边距
 27         //private string btntop; //上边距
 28         //private string btnreturntype; //返回值类型
 29         //private string btncode; //调用代码
 30 
 31         private string arrange; //扩展区按钮布局
 32         private string firstleft; //第一个按钮的左边距
 33         private string firsttop; //第一个按钮的上边距
 34         private string horizontal; //水平间距
 35         private string vertical; //垂直间距
 36 
 37         private string filePath; //文件路径
 38         private static Configer current; //唯一实例
 39 
 40         #endregion
 41 
 42         /// <summary>
 43         /// 因为不需要多个实例，所以采用了单例模式，由Current属性来获取唯一的实例
 44         /// </summary>
 45         /// <param name="filepath">文件Url</param>
 46         private Configer(string filepath)
 47         {
 48             this.filePath = filepath;
 49             //version = GetNodeProperty("FunBtn//info", "version");
 50             //updatetime = GetNodeProperty("FunBtn//info", "updatetime"); ;
 51             //isautoupdate = GetNodeProperty("FunBtn//info", "isautoupdate");
 52             //funbtnwidth = GetNodeProperty("FunBtn//btnsetting//set[@name='funbtn']", "width");
 53             //funbtnheight = GetNodeProperty("FunBtn//btnsetting//set[@name='funbtn']", "height");
 54             //expandbtnwidth = GetNodeProperty("FunBtn//btnsetting//set[@name='expandbtn']", "width");
 55             //expandbtnheight = GetNodeProperty("FunBtn//btnsetting//set[@name='expandbtn']", "height");
 56         }
 57 
 58         /// <summary>
 59         /// 获取当前配置。
 60         /// </summary>
 61         /// <param name="filepath">配置文件路径</param>
 62         /// <returns>返回唯一实例</returns>
 63         public static Configer Current(string filepath)
 64         {
 65             if (current == null)
 66             {
 67                 current = new Configer(filepath);
 68             }
 69             //current = new Configer(filepath);
 70             return current;
 71         }
 72 
 73         #region   基本配置信息
 74 
 75         /// <summary>
 76         /// 获取基本信息
 77         /// </summary>
 78         public void GetInfo()
 79         {
 80             version = GetNodeProperty("FunBtn//info", "version");
 81             updatetime = GetNodeProperty("FunBtn//info", "updatetime"); ;
 82             isautoupdate = GetNodeProperty("FunBtn//info", "isautoupdate");
 83             funbtnwidth = GetNodeProperty("FunBtn//btnsetting//set[@name='funbtn']", "width");
 84             funbtnheight = GetNodeProperty("FunBtn//btnsetting//set[@name='funbtn']", "height");
 85             expandbtnwidth = GetNodeProperty("FunBtn//btnsetting//set[@name='expandbtn']", "width");
 86             expandbtnheight = GetNodeProperty("FunBtn//btnsetting//set[@name='expandbtn']", "height");
 87         }
 88 
 89         ///   <summary> 
 90         ///   版本号
 91         ///   </summary> 
 92         public string Version
 93         {
 94             get { return version; }
 95             set { SetNodeProperty("FunBtn//info", "version", value); }
 96         }
 97 
 98         ///   <summary> 
 99         ///   更新时间 
100         ///   </summary> 
101         public string UpdateTime
102         {
103             get { return updatetime; }
104             set { SetNodeProperty("FunBtn//info", "updatetime", value); }
105         }
106 
107         ///   <summary> 
108         ///   是否自动更新 
109         ///   </summary> 
110         public string IsAutoUpdate
111         {
112             get { return isautoupdate; }
113             set { SetNodeProperty("FunBtn//info", "isautoupdate", value); }
114         }
115 
116         /// <summary>
117         /// 功能区按钮宽度
118         /// </summary>
119         public string FunBtnWidth
120         {
121             get { return funbtnwidth; }
122             set
123             {
124                 SetNodeProperty("FunBtn//btnsetting//set[@name='funbtn']", "width", value);
125             }
126         }
127 
128         /// <summary>
129         /// 功能区按钮高度
130         /// </summary>
131         public string FunBtnHeight
132         {
133             get { return funbtnheight; }
134             set
135             {
136                 SetNodeProperty("FunBtn//btnsetting//set[@name='funbtn']", "height", value);
137             }
138         }
139 
140         /// <summary>
141         /// 扩展区按钮宽度
142         /// </summary>
143         public string ExpandBtnWidth
144         {
145             get { return expandbtnwidth; }
146             set
147             {
148                 SetNodeProperty("FunBtn//btnsetting//set[@name='expandbtn']", "width", value);
149             }
150         }
151 
152         /// <summary>
153         /// 扩展区按钮高度
154         /// </summary>
155         public string ExpandBtnHeight
156         {
157             get { return expandbtnheight; }
158             set
159             {
160                 SetNodeProperty("FunBtn//btnsetting//set[@name='expandbtn']", "height", value);
161                 ;
162             }
163         }
164 
165         #endregion
166 
167         #region   按钮配置信息
168         public struct BtnInfo
169         {
170             public string BtnName;//按钮名称
171             public string BtnText; //按钮显示文本
172             public string BtnType; //按钮类型
173             public string BtnLeft; //左边距
174             public string BtnTop; //上边距
175             public string BtnReturnType; //返回值类型
176             public string BtnCode; //调用代码
177         }
178 
179         /// <summary> 
180         /// 获取按钮信息
181         /// </summary> 
182         public BtnInfo GetBtnInfo(string btnName)
183         {
184             var btnInfo = new BtnInfo();//定义一个btn信息结构
185             btnInfo.BtnName = GetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "name");
186             btnInfo.BtnText = GetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "value");
187             btnInfo.BtnType = GetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "type");
188             btnInfo.BtnLeft = GetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "left");
189             btnInfo.BtnTop = GetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "top");
190             btnInfo.BtnReturnType = GetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "returntype");
191             btnInfo.BtnCode = GetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "code");
192             return btnInfo;
193         }
194 
195         /// <summary> 
196         /// 设置按钮信息
197         /// </summary> 
198         public void SetBtnInfo(string btnName, BtnInfo btnInfo)
199         {
200             SetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "value", btnInfo.BtnText);
201             SetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "type", btnInfo.BtnType);
202             SetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "left", btnInfo.BtnLeft);
203             SetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "top", btnInfo.BtnTop);
204             SetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "returntype", btnInfo.BtnReturnType);
205             SetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "code", btnInfo.BtnCode);
206             SetNodeProperty("FunBtn//btndetail//btn[@name='" + btnName + "']", "name", btnInfo.BtnName);
207         }
208         #endregion
209 
210         #region 特定功能部分
211         /// <summary>
212         /// 显示树形结构中的功能
213         /// </summary>
214         /// <param name="tree"></param>
215         public void ShowButtons(TreeView tree)
216         {
217             if (!File.Exists(filePath)) return;
218             XmlDocument xmlDoc = new XmlDocument();
219             xmlDoc.Load(filePath);
220 
221             //清空所有节点
222             tree.Nodes.Clear();
223 
224             //获取根节点
225             XmlNodeList nodelist = xmlDoc.SelectNodes("FunBtn//btnsetting//set");
226             if (nodelist != null)
227             {
228                 foreach (var VARIABLE in nodelist)
229                 {
230                     TreeNode node = new TreeNode();
231                     XmlAttributeCollection xmlAttributeCollection = ((XmlNode)VARIABLE).Attributes;
232                     if (xmlAttributeCollection != null)
233                     {
234                         //添加根节点:功能区和扩展区
235                         node.Name = xmlAttributeCollection["name"].Value;
236                         node.Text = xmlAttributeCollection["value"].Value;
237 
238                         //添加所属的子节点
239                         ShowChildBtn(node, node.Name);
240                         tree.Nodes.Add(node);
241                     }
242                 }
243             }
244             tree.ExpandAll();//全部展开
245         }
246 
247         /// <summary>
248         /// 根据按钮类型，将其子项加载到给定的节点中
249         /// </summary>
250         /// <param name="treeNode">父节点</param>
251         /// <param name="btnType">按钮类型</param>
252         private void ShowChildBtn(TreeNode treeNode, string btnType)
253         {
254             if (!File.Exists(filePath)) return;
255             XmlDocument xmlDoc = new XmlDocument();
256             xmlDoc.Load(filePath);
257 
258             //获取按钮信息设置
259             var selectSingleNode = xmlDoc.SelectNodes("FunBtn//btndetail//btn[@type='" + btnType + "']");
260             if (selectSingleNode != null)
261             {
262                 XmlNodeList nodelist = selectSingleNode;
263 
264                 foreach (var VARIABLE in nodelist)
265                 {
266                     TreeNode node = new TreeNode();
267                     XmlAttributeCollection xmlAttributeCollection = ((XmlNode)VARIABLE).Attributes;
268                     if (xmlAttributeCollection != null)
269                     {
270                         //添加功能区或扩展区的所属功能按钮
271                         node.Name = xmlAttributeCollection["name"].Value;
272                         node.Text = xmlAttributeCollection["value"].Value;
273                         treeNode.Nodes.Add(node);
274                     }
275                 }
276             }
277         }
278 
279 
280         /// <summary>
281         /// 按钮信息
282         /// </summary>
283         public struct BtnArray
284         {
285             public int Size;      //可显示按钮数量
286             public int RowsCount;    //行数
287             public int ColsCount;    //列数
288             public int Horizontal;  //水平间距
289             public int Vertical;    //垂直间距
290             public int FirstLeft;   //第一个按钮左边距
291             public int FirstTop;    //第一个按钮上边距
292             public int Width;       //宽度
293             public int Height;      //高度
294 
295         }
296 
297         /// <summary>
298         /// 往控件中加载按钮
299         /// </summary>
300         /// <param name="control">控件</param>
301         /// <param name="path">节点路径</param>
302         /// <param name="btnArray">要生成按钮的信息</param>
303         public void LoadButton(Control control, string path, BtnArray btnArray)
304         {
305 
306             if (!File.Exists(filePath)) return;
307             XmlDocument xmlDoc = new XmlDocument();
308             xmlDoc.Load(filePath);
309 
310             //排列位置,第一个按钮左边距,上边距,列数,水平间距,垂直间距,宽度，高度
311             int rank = 0, firstleft = 0, firsttop = 0, colsCount = 0, horizontal = 0, vertical = 0, width = 0, height = 0;
312 
313             firstleft = btnArray.FirstLeft;//第一个按钮左边距
314             firsttop = btnArray.FirstTop;//第一个按钮上边距       
315             colsCount = btnArray.ColsCount;//列数      
316             horizontal = btnArray.Horizontal;//水平间距
317             vertical = btnArray.Vertical; //垂直间距
318             width = btnArray.Width;//宽度
319             height = btnArray.Height;//高度
320 
321 
322             //获取按钮节点
323             XmlNodeList nodelist = xmlDoc.SelectNodes(path);
324             if (nodelist != null)
325             {
326                 for (int i = 0; i < nodelist.Count; i++)
327                 {
328                     XmlAttributeCollection xmlAttributeCollection = nodelist[i].Attributes;
329                     if (xmlAttributeCollection != null)
330                     {
331                         rank = int.Parse(xmlAttributeCollection["rank"].Value); //获取排列位置
332                         if (rank == -1 || rank >= btnArray.Size) continue;//rank为-1或者超过显示额度时，则不显示。
333                         Button btn = new Button();
334                         //计算每个按钮的坐标
335                         int x = firstleft + (rank % colsCount) * (horizontal + width);
336                         int y = firsttop + (rank / colsCount) * (vertical + height);
337 
338                         //添加根节点:功能区和扩展区
339                         btn.Name = xmlAttributeCollection["name"].Value;//按钮名称
340                         btn.Text = xmlAttributeCollection["value"].Value;//按钮显示文本
341                         btn.Location = new Point(x, y);//设定按钮位置跟矩形框一致
342                         btn.Size = new Size(width + 1, height + 1);//设定按钮大小比矩形框略大1
343                         btn.Tag = rank;//记录第几个位置
344                         control.Controls.Add(btn);
345                         btn.BringToFront();//置顶按钮
346                     }
347                 }
348             }
349         }
350 
351 
352         /// <summary>
353         /// 为节点列表的特定属性写入相同的值
354         /// </summary>
355         /// <param name="path">路径</param>
356         /// <param name="nodeProperty">属性名</param>
357         public string[] GetAssembly(string path, string nodeProperty)
358         {
359             if (!File.Exists(filePath)) return null;
360             var xmlDoc = new XmlDocument();
361             xmlDoc.Load(filePath);
362 
363             string[] assemblies = null;
364 
365             //获取节点列表
366             XmlNodeList nodelist = xmlDoc.SelectNodes(path);
367             if (nodelist != null)
368             {
369                 //根据节点个数,实例化数组,用于存在引用的dll名称
370                 assemblies = new string[nodelist.Count];
371 
372                 for (int i = 0; i < nodelist.Count; i++)//遍历列表
373                 {
374                     var element = (XmlElement)nodelist[i];
375                     assemblies[i] = element.GetAttribute(nodeProperty);//装载dll到数组中
376                 }
377             }
378             return assemblies;//返回数组
379         }
380 
381         #endregion
382 
383 
384         /// <summary>                                                                         
385         /// 获取节点值 
386         /// </summary>
387         /// <param name="path">节点路径</param>
388         /// <param name="nodeProperty">节点名称</param>
389         /// <returns>属性值</returns>
390         public string GetNodeProperty(string path, string nodeProperty)
391         {
392             XmlDocument doc = new XmlDocument();
393             //加载文件
394             doc.Load(filePath);
395 
396             XmlElement element = null;
397 
398             //节点元素
399             element = (XmlElement)(doc.SelectSingleNode(path));
400 
401             if (element != null)
402             {
403                 return element.GetAttribute(nodeProperty);
404             }
405             else
406             {
407                 return " ";
408             }
409         }
410 
411         /// <summary>                                                                         
412         /// 获取节点值 
413         /// </summary>
414         /// <param name="path">节点路径</param>
415         /// <param name="nodeProperty">节点名称</param>
416         /// <returns>属性值</returns>
417         public string[] GetNodeProperties(string path, string nodeProperty)
418         {
419             
420             XmlDocument doc = new XmlDocument();
421             //加载文件
422             doc.Load(filePath);
423 
424             //获取根节点
425             XmlNodeList nodelist = doc.SelectNodes(path);
426             string[] result= new string[nodelist.Count];
427             if (nodelist != null)
428             {
429                 int i=0;
430                 foreach (var VARIABLE in nodelist)
431                 {
432                     TreeNode node = new TreeNode();
433                     XmlAttributeCollection xmlAttributeCollection = ((XmlNode)VARIABLE).Attributes;
434                     if (xmlAttributeCollection != null)
435                     {
436                         //获取节点中的某项属性值，加入到数组中
437                         result[i] = xmlAttributeCollection[nodeProperty].Value;
438                         i++;
439                     }
440                 }
441             }
442             return result;
443         }
444 
445         /// <summary> 
446         /// 写入属性值
447         /// </summary> 
448         /// <param name="path">节点路径</param>
449         /// <param   name= "nodeProperty"> 属性名称</param>
450         /// <param   name= "nodeValue">属性值</param> 
451         public void SetNodeProperty(string path, string nodeProperty, string nodeValue)
452         {
453             var doc = new XmlDocument();
454             //加载文件
455             doc.Load(filePath);
456 
457             XmlElement element = null;
458 
459             //获取版本信息
460             element = (XmlElement)(doc.SelectSingleNode(path));
461 
462             if (element != null)
463             {
464                 //给某个属性写入值
465                 element.SetAttribute(nodeProperty, nodeValue);
466             }
467             doc.Save(filePath);
468         }
469 
470         /// <summary>
471         /// 获取节点值 
472         /// </summary>
473         /// <param name="path">节点路径</param>
474         /// <param name="nodeProperty">节点名称</param>
475         /// <returns>属性值</returns>
476         public string GetNodeValue(string path, string nodeProperty)
477         {
478             XmlDocument doc = new XmlDocument();
479             //加载文件
480             doc.Load(filePath);
481 
482             XmlNode node = null;
483 
484             //获取节点
485             node = (doc.SelectSingleNode(path));
486 
487             if (node != null)
488             {
489                 //返回节点内容
490                 return node.Value;
491             }
492             else
493             {
494                 return " ";
495             }
496         }
497 
498         /// <summary> 
499         /// 写入节点值
500         /// </summary> 
501         /// <param name="path">节点路径</param>
502         /// <param   name= "nodeProperty"> 属性名称</param>
503         /// <param   name= "nodeValue">属性值</param> 
504         public void SetNodeValue(string path, string nodeProperty, string nodeValue)
505         {
506             var doc = new XmlDocument();
507             //加载文件
508             doc.Load(filePath);
509 
510             XmlNode node = null;
511 
512             //获取节点
513             node = (doc.SelectSingleNode(path));
514 
515             if (node != null)
516             {
517                 //在节点中写入内容
518                 node.Value = nodeValue;
519             }
520             doc.Save(filePath);
521         }
522 
523 
524         /// <summary>
525         /// 为节点列表的特定属性写入相同的值
526         /// </summary>
527         /// <param name="path">路径</param>
528         /// <param name="nodeProperty">属性名</param>
529         /// <param name="nodeValue">属性值</param>
530         public void SetAllNodeProperty(string path, string nodeProperty, string nodeValue)
531         {
532             if (!File.Exists(filePath)) return;
533             var xmlDoc = new XmlDocument();
534             xmlDoc.Load(filePath);
535 
536             //获取节点列表
537             var selectSingleNode = xmlDoc.SelectNodes(path);
538             if (selectSingleNode != null)
539             {
540                 XmlNodeList nodelist = selectSingleNode;
541 
542                 foreach (var VARIABLE in nodelist)//遍历列表
543                 {
544                     XmlElement element = (XmlElement)VARIABLE;
545                     //((XmlElement)VARIABLE).Attributes[nodeProperty].Value = nodeValue;
546                     element.SetAttribute(nodeProperty, nodeValue);
547                 }
548             }
549             xmlDoc.Save(filePath);
550         }
551 
552         /// <summary>
553         /// 创建节点
554         /// </summary>
555         /// <param name="path">父节点路径</param>
556         /// <param name="name">节点名称</param>
557         /// <param name="nodeProperties">属性数组</param>
558         /// <param name="nodeValues">属性值数组</param>
559         public void CreateNode(string path,string name, string[] nodeProperties, string[] nodeValues)
560         {
561             if (!File.Exists(filePath)) return;
562             XmlDocument xmlDoc = new XmlDocument();
563             xmlDoc.Load(filePath);
564 
565             //获取按钮信息设置
566             var selectSingleNode = xmlDoc.SelectSingleNode(path);
567             if (selectSingleNode != null)
568             {
569                 XmlElement xmlElement = xmlDoc.CreateElement(name);
570 
571                 //遍历属性数组，一次添加
572                 for (int i = 0; i < nodeProperties.Length; i++)
573                 {
574                     //添加属性
575                     xmlElement.SetAttribute(nodeProperties[i], nodeValues[i]);
576                 }
577                 selectSingleNode.AppendChild(xmlElement);
578             }
579             xmlDoc.Save(filePath);//保存
580         }
581 
582 
583         /// <summary>
584         /// 移除节点
585         /// </summary>
586         /// <param name="path">父节点路径</param>
587         /// <param name="name">子节点名称</param>
588         public void RemoveNode(string path,string name)
589         {
590             if (!File.Exists(filePath)) return;
591             XmlDocument xmlDoc = new XmlDocument();
592             xmlDoc.Load(filePath);
593 
594             //获取父节点
595             var selectSingleNode = xmlDoc.SelectSingleNode(path);
596             if (selectSingleNode != null)
597             {
598                 //获取子节点
599                 var node=selectSingleNode.SelectSingleNode(name);
600 
601                 if (node != null)
602                 {
603                     selectSingleNode.RemoveChild(node);
604                 }
605             }
606             xmlDoc.Save(filePath);//保存
607         }
608     }
609 }

 

 配置文件App.Config文件：

 

View Code

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <FunBtn>
 3   <!-- 版本信息 -->
 4   <info version="1.00" updatetime="2013-01-01 10:00:00.123" isautoupdate="true" />
 5   <!-- 引用的程序集和命名空间 -->
 6   <assembly>
 7     <dll name="system.dll" />
 8     <dll name="system.data.dll" />
 9     <dll name="system.xml.dll" />
10     <dll name="system.windows.forms.dll" />
11     <dll name="IBLL.dll" />
12     <dll name="BLL.dll" />
13     <dll name="Entity.dll" />
14     <dll name="LED_Model.dll" />
15     <dll name="FunButton.dll" />
16     <dll name="CashierSystem.exe" />
17     <using name="using System;" />
18     <using name="using System.Data;" />
19     <using name="using System.Data.SqlClient;" />
20     <using name="using System.Data.OleDb;" />
21     <using name="using System.Xml;" />
22     <using name="using FunButton;" />
23     <using name="using CashierSystem;" />
24     <using name="using System.Windows.Forms;" />
25   </assembly>
26   <!-- 按钮大小设置 -->
27   <btnsetting>
28     <set name="funbtn" value="功能区按钮" width="105" height="60" />
29     <set name="expandbtn" value="扩展区按钮" width="135" height="60" />
30     <arrange name="2x4" firstleft="10" firsttop="5" horizontal="25" vertical="15" />
31     <arrange name="3x3" firstleft="30" firsttop="25" horizontal="115" vertical="85" />
32     <arrange name="3x4" firstleft="30" firsttop="25" horizontal="70" vertical="24" />
33     <arrange name="4x3" firstleft="30" firsttop="40" horizontal="30" vertical="65" />
34     <arrange name="4x4" firstleft="30" firsttop="25" horizontal="30" vertical="24" />
35     <more using="4x4" />
36   </btnsetting>
37   <!-- 按钮属性和方法 -->
38   <btndetail>
39     <btn name="btnDelOrder" value="删除订单" type="funbtn" rank="1" left="140" top="5" returntype="void" code="new FunBtn().DelOrder(frmMain.frm);" />
40     <btn name="btnCheckOut" value="结 账" type="funbtn" rank="0" left="10" top="5" returntype="void" code="new FunBtn().CheckOut(frmMain.frm)" />
41     <btn name="btnClose" value="退出" type="funbtn" rank="2" left="10" top="80" returntype="void" code="Application.Exit()" />
42     <btn name="btnDelAllOrder" value="整单删除" type="funbtn" rank="3" left="140" top="80" returntype="void" code="new FunBtn().DelAllOrder(frmMain.frm);" />
43     <btn name="btnMore" value="更 多" type="funbtn" rank="6" left="10" top="230" returntype="void" code="new FunBtn().More(frmMain.frm)" />
44     <btn name="btnHangOrder" value="挂 单" type="funbtn" rank="4" left="10" top="155" returntype="void" code="new FunBtn().HangOrder(frmMain.frm)" />
45     <btn name="btnGetOrder" value="取 单" type="funbtn" rank="5" left="140" top="155" returntype="void" code="new FunBtn().GetOrder()" />
46     <btn name="btnOpenCashBox" value="开钱箱" type="funbtn" rank="-1" left="140" top="230" returntype="void" code="new FunBtn().OpenCashBox(frmMain.frm)" />
47     <btn name="btnReprint" value="重打" type="expandbtn" rank="6" left="360" top="109" returntype="void" code="new FunBtn().RePrint()" />
48     <btn name="btnCheckCash" value="下班交款" type="expandbtn" rank="0" left="30" top="25" returntype="void" code="new FunBtn().CheckCash()" />
49     <btn name="btnQueryMember" value="会员查询" type="expandbtn" rank="2" left="360" top="25" returntype="void" code="new FunBtn().QueryMember()" />
50     <btn name="btnLock" value="锁屏" type="expandbtn" rank="5" left="195" top="109" returntype="void" code="new FunBtn().Lock()" />
51     <btn name="btnMemberMgr" value="会员管理" type="expandbtn" rank="1" left="195" top="25" returntype="void" code="new FunBtn().MemberMgr()" />
52     <btn name="btnRegister" value="会员注册" type="expandbtn" rank="9" left="195" top="193" returntype="void" code="new FunBtn().Register()" />
53     <btn name="btnRecharge" value="会员充值" type="expandbtn" rank="10" left="360" top="193" returntype="void" code="new FunBtn().Recharge()" />
54     <btn name="btnLockCard" value="会员挂失" type="expandbtn" rank="-1" left="30" top="10" returntype="void" code="new FunBtn().LockCard()" />
55     <btn name="btnQueryConsume" value="消费查询" type="expandbtn" rank="-1" left="30" top="277" returntype="void" code="new FunBtn().QueryConsume()" />
56     <btn name="btnModifyPwd" value="修改密码" type="expandbtn" rank="4" left="30" top="109" returntype="void" code="new FunBtn().ModifyPwd()" />
57     <btn name="btnQuit" value="返 回" type="expandbtn" rank="15" left="525" top="277" returntype="void" code="new FunBtn().Quit()" />
58     <btn name="btnExit" value="退 出" type="expandbtn" rank="13" left="195" top="277" returntype="void" code="new FunBtn().Exit(frmMain.frm)" />
59     <btn name="btnReturnOrder" value="退 单" type="expandbtn" rank="3" left="525" top="25" returntype="void" code="new FunBtn().ReturnOrder()" />
60     <btn name="btnSetAuth" value="授权管理" type="expandbtn" rank="-1" left="195" top="315" returntype="void" code="new FunBtn().SetAuth(frmMain.frm)" />
61     <btn name="btnQueryRecharge" value="充值查询" type="expandbtn" rank="-1" left="30" top="277" returntype="void" code="new FunBtn().QueryRecharge()" />
62     <btn name="btnReStart" value="重新启动" type="expandbtn" rank="12" left="30" top="277" returntype="void" code="Application.Restart()" />
63     <btn name="btnRunSet" value="环境设置" type="expandbtn" rank="7" left="525" top="109" returntype="void" code="new FunBtn().RunSet()" />
64     <btn name="btnLogOut" value="注 销" type="expandbtn" rank="14" left="360" top="277" returntype="void" code="new FunBtn().LogOut(frmMain.frm)" />
65     <btn name="btnQueryUser" value="查询用户" type="expandbtn" rank="-1" left="360" top="25" returntype="void" code="new FunBtn().QueryUser()" />
66     <btn name="btnUpdate" value="软件升级" type="expandbtn" rank="8" left="30" top="193" returntype="void" code="new FunBtn().Update()" />
67     <btn name="btnBtnSetting" value="功能设置" type="expandbtn" rank="11" left="525" top="193" returntype="void" code="new FunBtn().BtnSetting()" />
68     <btn name="btnReLoadGoodsType" value="刷新菜系" type="funbtn" rank="7" left="140" top="230" returntype="void" code="new  FunBtn().ReLoadGoodsType(frmMain.frm)" />
69   </btndetail>
70 </FunBtn>

 

 

一切准备完毕后，在界面中添加按钮，并给每个按钮赋予事件：

 

View Code

 1         /// <summary>
 2         /// 往承载区加载按钮
 3         /// </summary>
 4         private void LoadButtons()
 5         {
 6             try
 7             {
 8                 Configer configer = Configer.Current(filePath);
 9                 Configer.BtnArray btnArray = new Configer.BtnArray();//按钮信息
10 
11                 btnArray.Size = 8;       //可显示数
12                 btnArray.RowsCount = 4;   //列数
13                 btnArray.ColsCount = 2;   //列数
14                 btnArray.Horizontal = int.Parse(configer.GetNodeProperty("FunBtn//btnsetting//arrange[@name='2x4']", "horizontal"));      //水平间距
15                 btnArray.Vertical = int.Parse(configer.GetNodeProperty("FunBtn//btnsetting//arrange[@name='2x4']", "vertical"));       //垂直间距
16                 btnArray.FirstLeft = int.Parse(configer.GetNodeProperty("FunBtn//btnsetting//arrange[@name='2x4']", "firstleft"));     //第一个按钮左边距
17                 btnArray.FirstTop = int.Parse(configer.GetNodeProperty("FunBtn//btnsetting//arrange[@name='2x4']", "firsttop"));     //第一个按钮上边距
18                 btnArray.Width = int.Parse(configer.GetNodeProperty("FunBtn//btnsetting//set[@name='funbtn']", "width"));       //宽度
19                 btnArray.Height = int.Parse(configer.GetNodeProperty("FunBtn//btnsetting//set[@name='funbtn']", "height")); ;     //高度
20 
21                 //加载功能按钮
22                 configer.LoadButton((System.Windows.Forms.Control)Panel1, "FunBtn//btndetail//btn[@type='funbtn']", btnArray);
23                 AddBtnEvent();//添加事件
24             }
25             catch (Exception exception)
26             {
27                 MessageBox.Show(exception.Message);
28             }
29         }

 

给每个按钮添加click事件：

 

View Code

 1         /// <summary>
 2         /// 为按钮添加click事件
 3         /// </summary>
 4         private void AddBtnEvent()
 5         {
 6             //遍历按钮
 7             foreach (Button VARIABLE in Panel1.Controls)
 8             {
 9                 VARIABLE.Click += Button_Click;
10             }
11         }
12 
13 
14 
15         /// <summary>
16         /// 为动态生成的功能区按钮定义click事件
17         /// </summary>
18         /// <param name="sender"></param>
19         /// <param name="e"></param>
20         public void Button_Click(object sender, EventArgs e)
21         {
22             try
23             {
24                 //根据按钮名称，调用对应的方法
25                 eval.Evaluate(((Button)sender).Name);
26 
27                 #region 多次编译（旧代码）
28 
29                 //Configer configer = Configer.Current(filePath);
30                 //string code = configer.GetNodeProperty(
31                 //    "FunBtn//btndetail//btn[@name='" + ((Button)sender).Name + "']", "code");
32                 //string returnType =
33                 //    configer.GetNodeProperty("FunBtn//btndetail//btn[@name='" + ((Button)sender).Name + "']",
34                 //                             "returntype");
35 
36                 //switch (returnType)
37                 //{
38                 //    case "void":
39                 //        Evaluator.EvaluateToVoid(code);
40                 //        break;
41                 //    case "object":
42                 //        Evaluator.EvaluateToObject(code);
43                 //        break;
44                 //    case "int":
45                 //        Evaluator.EvaluateToInteger(code);
46                 //        break;
47                 //    case "bool":
48                 //        Evaluator.EvaluateToBool(code);
49                 //        break;
50                 //    case "string":
51                 //        Evaluator.EvaluateToString(code);
52                 //        break;
53                 //}
54 
55                 #endregion
56 
57             }
58             catch (Exception exception)
59             {
60                 MessageBox.Show(exception.Message);
61             }
62 
63         }

 

 

到此为止，代码已经共享完毕了。或许大家看到这大段大段的代码很头疼，没着急，我给你简单的说说：

大概看几幅效果图片吧。

 

 

     

 

  

 

从以上几幅图中，可以看到，功能按钮是动态生成的，位置、数量都是可以随时调整的。每个按钮的功能也是可配置的。

这里面最主要的元素有3个，一是动态编译类Evaluator，二是配置文件，三则是写有功能的dll。

看看配置文件吧：包括引用的dll，引用的命名空间（这是调用dll中的功能时用的），按钮大小、位置、间隔、排列方式（用于动态生成功能按钮）及调用代码（一般写的是调用的dll中方法的代码）。

 

具体的原理是：在系统启动时，根据配置文件，动态加载该dll，动态编译Evaluator类，而后就可以调用方法了。按钮是读取配置文件生成的，包括大小，位置，名字，显示文字及执行的代码等。编译的Evaluator类中的方法名称是按按钮名称，方法体则是按钮调用的代码内容。给按钮添加一个click事件，click事件是执行Evaluator的与按钮名称相同的方法，那么就相当于执行调用的代码了。而调用的代码，是访问dll中的某个方法，这样就完成了功能可配置。也完成了具体功能和原系统的解耦。因为他们之间没有必然的联系。只要配置文件中，没有对该dll进行引用配置，那么他们就一点关系也没有。灵活度大大提高。

 

 

上面主要说的是C/S结构方面，而对于Web菜单结构的配置，则正符合热部署的情况。也是通过配置文件，把实际的功能性dll和项目进行了分离的动态安装。这点跟插件化开发同出一辙。插件的安装其实就是修改插件加载列表配置文件和copy插件所需要的dll及它所属的配置文件。 

 

在接下来的博文中，我会写有关热部署的例子。希望大家多多指点，多多支持。