您的位置:首页 > 编程语言 > ASP

Asp.net 2.0 自定义控件开发[实现自动计算功能(AutoComputeControl)][示例代码下载]

2007-12-18 22:09 866 查看
(一). 概述        
 业余时间做了一个非常有用的控件, 介绍一下.
         一般当我们要实现这样一个计算功能页面:
                      TextBox1(单价)  * TextBox2(数量) = TextBox3(总和);
        并且当在TextBox1或TextBox2中输入数据, 鼠标离开时, TextBox3控件能够即时重新计算新值(乘积).

       一般我们的做法步骤是:
              1. 拖三个控件到页面上, 默认三个TextBox控件ID分别为: TextBox1, TextBox1, 
                  TextBox3.

              2. 写个JavaScript 函数, 能够计算 TextBox1和TextBox2的乘积, 并赋值给TextBox3
                  即时最新值.

                       
                          function compute() 
                          {
                                  var _num = parseFloat(document.getElementById('TextBox1').value);
                                  var _price = parseFloat(document.getElementById('TextBox2').value);
                                  document.getElementById('TextBox3').value=_num*_price;
                         }
                      

              3. 注册TextBox1和TextBox2的onblur事件(TextBox控件失去焦点时触发).
                  this.TextBox1.Attributes.Add("onblur","compute()");
                  this.TextBox2.Attributes.Add("onblur","compute()"); 

             OK, 这样固然能够完成.  也存在以下缺点:
             1. 不够通用, 如果好多页面都需要这么一个控件,  那得写上面这些代码到所有
                 页面中. 开发效率不高. 且容易出错.

             2. 页面中代码比较乱. 嵌入好多JavaScript代码. 难以维护.
             3. 假如运算表达式非常复杂[如:  A*B+(B*C)+Math.E

  ] 每次设置JS也比较麻烦.

            基于以上缺陷,   
            下面是一个通用的自定义控件AutoComputeControl(自动计算),  能够弥补以上缺点, 
    且具有通用性, 

            特点如下:
              1. 使用简单,  只需设置一个表达式属性Expression, 控件能够自动完成所有JS脚本.
                  其中表达式由: 运算符和变量组成(控件的ID), 等一下会详细介绍使用方法.

              2. 不仅支持简单运算, 更大的优势是支持复杂表达式, 如:

                  price*(num+2*(3+6))*Math.E = sum ,  即
                 TextBox1*(TextBox2+2*(3+6)) * Math.E =TextBox3            

                  仅通过将控件的: ID和运算符 任意组合成计算表达式赋值给控件Expression属性, 

                  其它的工作由本控件来完成, 本控件能够自动生成所有JS脚本. 并最终在页面客
     户端呈现.  

             3. 另外, 支持Math对象下面的属性和方法:
                       Math属性:   Math.E    Math.LN10 Math.LN2  Math.LOG10E  Math.LOG2E  
                                             Math.PI   Math.SQRT1_2     Math.SQRT2

                      Math方法:    Math.abs(x)   Math.acos(x)   Math.asin(x)   Math.atan(x)   
                                             Math.atan2(x,y)    Math.ceil(x)   Math.floor(x)   Math.cos(x) 
                                             Math.exp(x)   Math.log(x)   Math.max(x,y)   Math.min(x,y)   
                                             Math.pow(x,y)   Math.random()   Math.round(20.49)   Math.sin(x)
                                             Math.sqrt(x)   Math.tan(x)

                       例如:   Math.sin(Math.sqrt(price1*price2))+Math.E*num=sum

                           即    Math.sin(Math.sqrt(TextBox1*TextBox2))+Math.E*TextBox3=TextBox4
             4. 最终用户还可以在控件中输入表达式:
                      例如, 用户在TextBox1框中输入: 6*(5+2)
                              再在TextBox2中输入: 3+Math.E*Math.PI
                              再把表达式: TextBox1*(TextBox2+2*(3+6)) * Math.E =TextBox3            
                              赋值给本控件属性Expression, 仍然能够正确计算出结果.
             5. 在一个页面中放多个本控件.
                 比如: 拖个本控件到页面跟 TextBox1/TextBox2/TextBox3 组合,
                         再拖另一个控件跟另一组  TextBox4/TextBox5/TextBox5  组合.
                 注意: 不要两组表达式产生冲突, 比如把TextBox1即在第一组又在
                         第二组, 这样脚本生成是正确的, 但这样自动生成的客户端脚本, 会
                         为TextBox1注册两个onblur事件, 那么默认第二个onblur起效, 不能
                         同时起效.  这是JavaScript 语法规定的.  
                                                

          实现原理:   本自定义控件的Expression属性, 如: TextBox1*(TextBox2+TexBox3)*0.90=TextBox4
                             中包括:
                                  1. 控件的ID.  2. 表达式之间的关系.
                             然后自定义控件内核代码会:
                                  1. 用编译算法扫描表达式属性(Expression)值, 分析运算关系.
                                  2. 根据运算关系动态生成要呈现到客户端的JavaScript, 再最终由自定义控件呈现.

(二).  使用步骤
         1. 拖三个TextBox控件到页面上,  如图:


        2. 设置TextBox1的ID属性为: price;   TextBox2的ID属性为: num;  TextBox3的ID属性为: sum.        3. 再添加一个AutoCompute控件(本文章主讲控件), 并设置其: Expression 属性值为:             price * num = sum ,  意思是: [单价] * [数量] = [总额]        4. 运行即可.  运行后当输入[单价]和[数量]时, 程式能够自动计算[总额]的值.            测试: 当鼠标从[单价]或[数量]控件失去焦点时, 总额值能够重新被计算显示.       5. 扩展:                 a. 您也可以输入更复杂的表达式, 比如从上面DropDownList(测试用的控件)里面随便选几个.               b. 不仅能够计算三个TextBox的表达式(如上), 您还可以添加N个TextBox表达式.        功能比较强大吧  :) :)  (三). 表达式规则:        支持JavaScript运算规则,  并支持Math对象的所有属性和方法.(四). 核心代码       1. Node类文件Node.cs, 用于编译算法中存储数据结点和字符结点 1



/**//// 
 2

    /// Author: [ ChengKing(ZhengJian) ] 
 3

    /// Blog:   Http://blog.csdn.net/ChengKing
 4

    /// 
 5

    /// 
 6

    /// Node 的摘要说明
 7

    /// 
 8

    /// 
 9

    /// 结点类[操作符结点] 
10

    /// 
11

    public class Node
12



    

{
13

        public string str;       //存储本节点字串
14

        public int startIndex;   //用于存储一个结点所在[运算表达式]的开始索引位置
15

        public int endIndex;     //用于存储一个结点所在[运算表达式]的结束索引位置    
16


17


18

        public Node(int startIndex, int endIndex, string str)
19



        

{
20

            this.str = str;
21

            this.startIndex = startIndex;
22

            this.endIndex = endIndex;        
23

        }
24

    }       2. 主要控件类 AutoCompute.cs 代码 1 /// 
 2     /// Author: [ ChengKing(ZhengJian) ] 
 3     /// Blog:   Http://blog.csdn.net/ChengKing
 4     /// 
 5     [DefaultProperty("Text")]
 6     [ToolboxData("<{0}:AutoCompute runat=server>")]
 7     public class AutoCompute : Control
 8     {
 9         [Bindable(true)]
10         //[Category("外观")]
11         [DefaultValue("[AutoCompute /"AutoCompute1/"]")]
12         [Localizable(true)]
13         public string Text
14         {
15             get
16             {
17                 String s = (String)ViewState["Text"];
18                 return ((s == null) ? String.Empty : s);
19             }
20 
21             set
22             {
23                 ViewState["Text"] = value;
24             }
25         }
26 
27         [Bindable(true)]        
28         [DefaultValue("")]
29         [Localizable(true)]
30         public string Expression
31         {
32             get
33             {
34                 string s = (string)this.ViewState["Expression"];
35                 return ((s == null) ? String.Empty : s);
36             }
37             set
38             {
39                 this.ViewState["Expression"] = value;
40             }
41         }
42 
43         protected override void Render(HtmlTextWriter writer)
44         {
45             if (DesignMode)
46             {
47                 this.Controls.Clear();
48                 LiteralControl lc = new LiteralControl();
49                 lc.Text = this.Text;
50                 this.Controls.Add(lc);
51             }         
52             base.Render(writer);
53         }
54 
55         protected override void OnPreRender(EventArgs e)
56         {
57             base.OnPreRender(e);
58 
59             ConvertHelper _ConvertHelper = new ConvertHelper();
60             string strClientScript;
61             try
62             {
63                 if (this.Expression.Trim().Length != 0)
64                 {
65                     _ConvertHelper.Main(Page, this.Expression);
66                     _ConvertHelper.RegisterClientScript(this.Page);
67                 }
68                 else
69                 {
70                     strClientScript = "   alert('No Set [Expression] Property!');";
71                     if (!Page.ClientScript.IsStartupScriptRegistered("Default_Property"))
72                     {
73                         Page.ClientScript.RegisterStartupScript(this.GetType(), "Default_Property", strClientScript, true);
74                     }
75                 }
76             }
77             catch
78             {
79                 strClientScript = "   alert('The [Expression] format is not correct!');";
80                 if (!Page.ClientScript.IsStartupScriptRegistered("Default_Property"))
81                 {
82                     Page.ClientScript.RegisterStartupScript(this.GetType(), "Default_Property", strClientScript, true);
83                 }
84             }
85 
86         }
87 
88     }
       3. ConvertHelper.cs类文件, 主要实现编译算法以及JavaScript脚本生成注册功能.  1  /// 
  2     /// Author: [ ChengKing(ZhengJian) ] 
  3     /// Blog:   Http://blog.csdn.net/ChengKing
  4     /// 
  5     /// 
  6     /// ConvertHelper 的摘要说明
  7     /// 
  8     /// 
  9     /// 算法概述:
 10     ///  引用概念: [数据变量结点]: 用户命名的字串, 如: total = price*num, 则 "price" 字串就为数据变量结点
 11     ///  1. 抽取出操作运算符. 并记住所有运算符的索引
 12     ///  2. 两个操作符之间的字符串为[数据变量结点(用户命名的字串)], 但下面几种情况要排除:
 13     ///       a. 提取的相邻字符中, 右边字符为"("操作符时, 中间不是数据变量结点.
 14     ///       b. 两个操作符相邻时, 其中间没有字符串, 显然也就没有数据变量结点.
 15     ///       c. 数据变量结点必须是字符串变量, 不能为数值.
 16     ///       d. 排除Math.E等常量情况(Math.E/Math.LN10/Math.LN2/Math.LOG10E/Math.LOG2E/ Math.PI/Math.SQRT1_2/Math.SQRT2).
 17     /// 
 18     public class ConvertHelper
 19     {
 20         /// 
 21         /// 存放JavaScript运算符的各种结点
 22         /// 
 23         private string[] OP_Chars = new string[7] { "+", "-", "*", "/", "(", ")", "," };
 24 
 25         /// 
 26         /// 自定义变量前缀符号
 27         /// 
 28         private string VarPreSymbol = "_";
 29 
 30         /// 
 31         /// 存储要读取控件的属性(如: t.text/t.Value etc)
 32         /// 
 33         private string ValueSymbol = ".value";
 34 
 35         /// 
 36         /// 存储compute方法脚本变量
 37         ///   
 38         private string ComputeScript = "";
 39 
 40         /// 
 41         /// 存储onblur方法脚本变量
 42         ///   
 43         private string OnblurScript = "";
 44 
 45         /// 
 46         /// 区别于方法名的序列号[依次递增, 如: compute1, compute2, compute3 

 ]
 47         /// 
 48         private int SequenceNum = 1;
 49 
 50         /// 
 51         /// 抽取出运算符结点[其中包括运算符结点的位置信息]
 52         /// 
 53         /// 
 54         /// 
 55         private List BuildOPNode(string strObject)
 56         {
 57             int beginIndex = 0; //记录当前处理结点的起始索引       
 58             List nodes = new List();
 59 
 60 
 61             while (true)
 62             {
 63                 if (beginIndex == strObject.Length)
 64                 {
 65                     break;
 66                 }
 67 
 68                 for (int j = 0; j < OP_Chars.Length; j++)
 69                 {
 70                     if (strObject.Length - beginIndex >= OP_Chars[j].Length)
 71                     {
 72                         if (OP_Chars[j] == strObject.Substring(beginIndex, OP_Chars[j].Length))
 73                         {
 74                             //操作符
 75                             Node node = new Node(beginIndex, beginIndex + OP_Chars[j].Length - 1, strObject.Substring(beginIndex, OP_Chars[j].Length));
 76                             nodes.Add(node);
 77                             break;
 78                         }
 79                     }
 80                 }
 81                 beginIndex++;
 82             }
 83             return nodes;
 84         }
 85 
 86         /// 
 87         /// 根据运算符结点抽取出数据结点[其中包括数据结点的位置信息]
 88         /// 
 89         /// 
 90         /// 
 91         public List BuildDataNode(string strObject)
 92         {
 93             strObject = ClearSpace(strObject);
 94             List dataNodes = new List();
 95             List opNodes = this.BuildOPNode(strObject);
 96 
 97             //考虑表达式最左边是数据结点情况, 如: A+B 表达式中的A
 98             if (opNodes.Count > 0 && opNodes[0].startIndex != 0 && opNodes[0].str != "(")
 99             {
100                 string str = strObject.Substring(0, opNodes[0].startIndex);
101                 if (this.JudgeFigure(str) == false && this.IsIndexOfMath(str) == false)
102                 {
103                     Node node = new Node(0, opNodes[0].startIndex - 1, str);
104                     dataNodes.Add(node);
105                 }
106 
107             }
108 
109             //根据操作运算符求得中间的一系列数据结点
110             for (int i = 0; i < opNodes.Count - 1; i++)
111             {
112                 if (this.IsDataNodeBetweenOPNodes(opNodes[i], opNodes[i + 1], strObject))
113                 {
114                     Node node = new Node(opNodes[i].endIndex + 1, opNodes[i + 1].startIndex - 1, strObject.Substring(opNodes[i].endIndex + 1, opNodes[i + 1].startIndex - opNodes[i].endIndex - 1));
115                     dataNodes.Add(node);
116                 }
117             }
118 
119             //考虑最右端是数据结点情况, 如: A+B 表达式中的B
120             if (opNodes.Count > 0 && (opNodes[opNodes.Count - 1].endIndex != strObject.Length - 1))
121             {
122                 string str = strObject.Substring(opNodes[opNodes.Count - 1].endIndex + 1);
123                 if (this.JudgeFigure(str) == false && this.IsIndexOfMath(str) == false)
124                 {
125                     Node node = new Node(opNodes[opNodes.Count - 1].endIndex + 1, strObject.Length - 1, str);
126                     dataNodes.Add(node);
127                 }
128             }
129             return dataNodes;
130         }
131 
132         /// 
133         /// 判断相邻结点中间是否是数据结点
134         /// 
135         /// 
136         /// 
137         /// 
138         ///  根据以下定理进行判断
139         ///    a. 提取的相邻字符中, 右边字符为"("操作符时, 中间不是数据变量结点.
140         ///    b. 两个操作符相邻时, 其中间没有字符串, 显然也就没有数据变量结点.
141         ///    c. 数据变量结点必须是字符串变量, 不能为数值.
142         ///    d. 排除Math.E等常量情况(Math.E/Math.LN10/Math.LN2/Math.LOG10E/Math.LOG2E/ Math.PI/Math.SQRT1_2/Math.SQRT2).
143         private bool IsDataNodeBetweenOPNodes(Node leftNode, Node rightNode, string strObject)
144         {
145             //条件a
146             if (rightNode.str == "(")
147             {
148                 return false;
149             }
150 
151             //条件b
152             if (leftNode.endIndex + 1 == rightNode.startIndex)
153             {
154                 return false;
155             }
156 
157             //条件c
158             if (this.JudgeFigure(strObject.Substring(leftNode.endIndex + 1, rightNode.startIndex - leftNode.endIndex - 1)) == true)
159             {
160                 return false;
161             }                   
162             
163             if (this.IsIndexOfMath(strObject.Substring(leftNode.endIndex + 1, rightNode.startIndex - leftNode.endIndex - 1)))
164             {
165                 return false;
166             }
167 
168             return true;
169         }
170 
171         /// 
172         /// //判断是否Math.开头 排除(Math.E/Math.LN10/Math.LN2/Math.LOG10E/Math.LOG2E/ Math.PI/Math.SQRT1_2/Math.SQRT2)等常量
173         /// 
174         /// 
175         /// 
176         public bool IsIndexOfMath(string str)
177         {
178             if (str.IndexOf("Math.") == 0)
179             {
180                 return true;
181             }
182             return false;
183         }
184 
185         /// 
186         /// 判断是否是数字
187         /// 
188         /// 
189         /// 
190         private bool JudgeFigure(string str)
191         {
192             if (str.Trim().Length <= 0)
193                 return true;
194             int dot = 0;
195             if (str[0] == '.' || str[str.Length - 1] == '.')
196                 return false;
197             for (int i = 0; i < str.Length; i++)
198             {
199                 if (dot > 1) return false;
200                 if (Char.IsDigit(str, i))
201                 {
202                     continue;
203                 }
204                 if (str[i] == '.')
205                 {
206                     dot = dot + 1;
207                     continue;
208                 }
209                 return false;
210             }
211             return true;
212         }
213 
214         /// 
215         /// 返回处理后的表达式
216         /// 
217         /// 
218         /// 
219         /// 
220         private string CreateClientScript(Page page, string strAll, List nodes)
221         {
222             string strLeft = strAll.Substring(0, strAll.IndexOf("=")); ;
223             string strRight = strAll.Substring(strAll.IndexOf("=")+1);
224 
225             /// 
226             /// 生成并注册compute方法脚本
227             /// 
228             int intNumDataNodeCount = nodes.Count;
229 
230             //调整方法名, 防止多个表达式运算时, 方法名冲突
231             while (true)
232             {
233                 //bool flag = page.ClientScript.IsClientScriptBlockRegistered("compute" + SequenceNum.ToString());
234                 if (!page.ClientScript.IsClientScriptBlockRegistered(this.GetType(), "compute" + SequenceNum.ToString()))
235                 {
236                     if (!page.ClientScript.IsStartupScriptRegistered(this.GetType(), "onblur" + this.SequenceNum.ToString()))
237                     {
238                         break;
239                     }
240 
241                 }
242                 SequenceNum++;
243             }
244 
245             //生成脚本头JS字串
246             string strJSHead = " /n function compute" + this.SequenceNum.ToString() + "() /n { /n";            
247             //生成脚本体JS字串
248             string strJSBody = "";
249             for (int i = 0; i < intNumDataNodeCount; i++)
250             {
251                 strJSBody += "  var " + VarPreSymbol + nodes[i].str + " = parseFloat(document.getElementById('" + ((Control)page.FindControl(nodes[i].str)).ClientID + "')" + ValueSymbol + ");/n";  
252             }
253             strJSBody += "  document.getElementById('" + ((Control)page.FindControl(strRight)).ClientID + "')" + ValueSymbol; 
254             strJSBody += "=";
255 
256             for (int i = 0; i < intNumDataNodeCount; i++)
257             {
258                 strLeft = strLeft.Remove(nodes[i].startIndex, nodes[i].str.Length);
259                 strLeft = strLeft.Insert(nodes[i].startIndex, "_" + nodes[i].str);
260                 this.RepairNodes(ref nodes, i + 1);
261             }
262             strLeft += ";";
263             strJSBody += strLeft;
264             string strJSFoot = "/n }/n/n/n";
265 
266             string strReturnScript = strJSHead + strJSBody + strJSFoot;
267             this.ComputeScript = strReturnScript;
268 
269 
270 
271             /// 
272             /// 生成并注册onblur脚本(调用compute方法)
273             /// 
274             string strOnBlur = "/n/n";
275             for (int i = 0; i < nodes.Count; i++)
276             {                
277                 strOnBlur += "  document.getElementById('" + ((Control)page.FindControl(nodes[i].str)).ClientID + "')" + ".onblur=compute" + this.SequenceNum.ToString() + ";/n";
278             }
279             strOnBlur += "";
280             this.OnblurScript = strOnBlur;
281 
282 
283 
284             strReturnScript += strOnBlur;
285             return strReturnScript;
286         }
287 
288         /// 
289         /// 重新调整数据节点集合的索引值
290         /// 
291         /// 
292         /// 
293         private void RepairNodes(ref List nodes, int index)
294         {
295             for (int i = index; i < nodes.Count; i++)
296             {
297                 //6相当于前面数据结点插入的 ".value" 的长度
298                 nodes[i].startIndex = nodes[i].startIndex + VarPreSymbol.Length;
299                 nodes[i].endIndex = nodes[i].endIndex + VarPreSymbol.Length;
300             }
301         }
302 
303         public string Main(Page page, string strAll)
304         {
305             strAll = this.ClearSpace(strAll);
306             if (CheckParenthesesMatching(strAll) == false)
307             {
308                 page.Response.Write("

 括号不匹配!");
309                 return "";
310             }
311 
312             string strLeft = strAll.Substring(0, strAll.IndexOf("="));
313 
314             string strEndJS_Script = this.CreateClientScript(page, strAll, BuildDataNode(strLeft));
315             return strEndJS_Script;
316         }
317 
318         //检查括号是否匹配
319         private bool CheckParenthesesMatching(string strCheck)
320         {
321             int number = 0;
322             for (int i = 0; i < strCheck.Length; i++)
323             {
324                 if (strCheck[i] == '(') number++;
325                 if (strCheck[i] == ')') number--;
326                 if (number < 0) return false;//右括号不能在前面
327             }
328             if (number != 0)
329             {
330                 return false;
331             }
332             return true;
333         }
334 
335         //消去空格
336         private string ClearSpace(string str)
337         {
338             return str.Replace(" ", "");
339         }
340 
341         //注册客户端脚本
342         public bool RegisterClientScript(Page page)
343         {
344             if (this.OnblurScript.Length == 0 || this.ComputeScript.Length == 0)
345             {
346                 return false;
347             }
348 
349             if (!page.ClientScript.IsClientScriptBlockRegistered("compute" + this.SequenceNum.ToString()))
350             {
351                 page.ClientScript.RegisterClientScriptBlock(this.GetType(), "compute", this.ComputeScript, false);
352             }
353 
354             if (!page.ClientScript.IsStartupScriptRegistered("onblur" + this.SequenceNum.ToString()))
355             {
356                 page.ClientScript.RegisterStartupScript(this.GetType(), "onblur", this.OnblurScript, false);
357             }
358             return true;
359         }
360 
361     } (五). 示例代码下载        http://www.cnblogs.com/Files/MVP33650/自动计算控件.rar   (六). 其它相关自定义控件文章        http://blog.csdn.net/ChengKing/category/288694.aspx (七).此控件的第二个版本源码已经发布, 请看这里, 内容更精彩: http://blog.csdn.net/ChengKing/archive/2007/04/27/1587794.aspx         

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1562765
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: 
相关文章推荐