这篇文章主要介绍了DevExpress之TreeList用法,对于C#初学者有一定的借鉴价值,需要的朋友可以参考下
本文实例总结了DevExpress之TreeList用法，希望对大家学习C#程序设计起到一定的帮助作用。具体实例如下：

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Drawing;
   
4. using System.Windows.Forms;
   
5. using DevExpress.XtraBars;
   
6. using DevExpress.XtraTreeList;
   
7. using DevExpress.XtraTreeList.Nodes;
   
8. 
   
9. namespace DevExpressUtilHelpV3
   
10. {
    
11. public static class TreeListToolV3
    
12. {
    
13. public delegate string BuildPathRule(string nodeText, string fullPathInfo);
    
14. /// <summary>
    
15. /// 获取选中节点到根节点的所有信息
    
16. /// </summary>
    
17. /// <param name="focusedNode">TreeListNode</param>
    
18. /// <param name="columnID">列名称</param>
    
19. /// <param name="buildPathRule">规则委托</param>
    
20. /// <returns>路径信息</returns>
    
21. public static string FullPathInfo(this TreeListNode focusedNode, string columnID, BuildPathRule buildPathRule)
    
22. {
    
23. if (focusedNode == null)
    
24. throw new ArgumentNullException("focusedNode");
    
25. if (string.IsNullOrEmpty("columnID"))
    
26. throw new ArgumentNullException("columnID");
    
27. string _fullPathInfo = string.Empty;
    
28. _fullPathInfo = focusedNode.GetDisplayText(columnID);
    
29. while (focusedNode.ParentNode != null)
    
30. {
    
31. focusedNode = focusedNode.ParentNode;
    
32. string _nodeText = focusedNode.GetDisplayText(columnID).Trim();
    
33. _fullPathInfo = buildPathRule(_nodeText, _fullPathInfo);
    
34. }
    
35. return _fullPathInfo;
    
36. }
    
37. public delegate bool CompareNodeRule(TreeListNode focusedNode);
    
38. /// <summary>
    
39. /// 获取筛选节点到根节点的所有信息
    
40. /// </summary>
    
41. /// <param name="focusedNode">TreeListNode</param>
    
42. /// <param name="columnID">列名称</param>
    
43. /// <param name="compareNodeRule">规则委托</param>
    
44. /// <param name="buildPathRule">规则委托</param>
    
45. /// <returns>路径信息</returns>
    
46. public static string FilterPathInfo(this TreeListNode focusedNode, string columnID, CompareNodeRule compareNodeRule, BuildPathRule buildPathRule)
    
47. {
    
48. if (focusedNode == null)
    
49. throw new ArgumentNullException("focusedNode");
    
50. if (string.IsNullOrEmpty("columnID"))
    
51. throw new ArgumentNullException("columnID");
    
52. string _fullPathInfo = string.Empty;
    
53. _fullPathInfo = focusedNode.GetDisplayText(columnID);
    
54. while (focusedNode.ParentNode != null)
    
55. {
    
56. focusedNode = focusedNode.ParentNode;
    
57. if (compareNodeRule(focusedNode))
    
58. {
    
59. string _nodeText = focusedNode.GetDisplayText(columnID).Trim();
    
60. _fullPathInfo = buildPathRule(_nodeText, _fullPathInfo);
    
61. }
    
62. }
    
63. return _fullPathInfo;
    
64. }
    
65. /// <summary>
    
66. /// 递归遍历树节点
    
67. /// </summary>
    
68. /// <param name="tree"></param>
    
69. /// <param name="opreateRule"></param>
    
70. public static void LoopTree(this TreeList tree, Action<TreeListNode> opreateRule)
    
71. {
    
72. if (tree == null)
    
73. throw new ArgumentNullException("tree");
    
74. foreach (TreeListNode node in tree.Nodes)
    
75. {
    
76. opreateRule(node);
    
77. if (node.Nodes.Count > 0)
    
78. {
    
79. LoopTreeNodes(node, opreateRule);
    
80. }
    
81. }
    
82. }
    
83. /// <summary>
    
84. /// 递归遍历TreeListNode节点
    
85. /// </summary>
    
86. /// <param name="node"></param>
    
87. /// <param name="opreateRule"></param>
    
88. public static void LoopTreeNodes(this TreeListNode node, Action<TreeListNode> opreateRule)
    
89. {
    
90. if (node == null)
    
91. throw new ArgumentNullException("node");
    
92. foreach (TreeListNode _childNode in node.Nodes)
    
93. {
    
94. opreateRule(_childNode);
    
95. LoopTreeNodes(_childNode, opreateRule);
    
96. }
    
97. }
    
98. /// <summary>
    
99. /// 递归遍历TreeListNode,当opreateRule返回false停止循环
    
100. /// </summary>
     
101. /// <param name="node">TreeListNode</param>
     
102. /// <param name="opreateRule">Func<TreeListNode, bool></param>
     
103. public static void LoopTreeNodes_Break(this TreeListNode node, Func<TreeListNode, bool> opreateRule)
     
104. {
     
105. if (node == null)
     
106. throw new ArgumentNullException("node");
     
107. foreach (TreeListNode _childNode in node.Nodes)
     
108. {
     
109. if (!opreateRule(_childNode))
     
110. break;
     
111. LoopTreeNodes_Break(_childNode, opreateRule);
     
112. }
     
113. }
     
114. /// <summary>
     
115. /// 递归遍历TreeListNode,当opreateRule返回false跳出循环，直接进入下次循环
     
116. /// </summary>
     
117. /// <param name="node">TreeListNode</param>
     
118. /// <param name="opreateRule">Func<TreeListNode, bool></param>
     
119. public static void LoopTreeNodes_Continue(this TreeListNode node, Func<TreeListNode, bool> opreateRule)
     
120. {
     
121. if (node == null)
     
122. throw new ArgumentNullException("node");
     
123. foreach (TreeListNode _childNode in node.Nodes)
     
124. {
     
125. if (!opreateRule(_childNode))
     
126. continue;
     
127. LoopTreeNodes_Continue(_childNode, opreateRule);
     
128. }
     
129. }
     
130. public delegate bool CheckNodeRule(TreeListNode fucusedNode);
     
131. public delegate void CheckNodeNullRule();
     
132. /// <summary>
     
133. /// 节点为null检查
     
134. /// </summary>
     
135. /// <param name="fucusedNode">TreeListNode</param>
     
136. /// <param name="checkNodeRule">若为NULL,处理逻辑</param>
     
137. /// <returns>TreeListNode</returns>
     
138. public static TreeListNode CheckNull(this TreeListNode fucusedNode, CheckNodeNullRule checkNodeRule)
     
139. {
     
140. if (fucusedNode == null)
     
141. {
     
142. checkNodeRule();
     
143. return null;
     
144. }
     
145. return fucusedNode;
     
146. }
     
147. /// <summary>
     
148. /// 正对节点的检查逻辑
     
149. /// </summary>
     
150. /// <param name="fucusedNode">TreeListNode</param>
     
151. /// <param name="checkNodeRule">检查逻辑代码[委托]</param>
     
152. /// <returns>TreeListNode</returns>
     
153. public static TreeListNode Check(this TreeListNode fucusedNode, CheckNodeRule checkNodeRule)
     
154. {
     
155. if (fucusedNode != null)
     
156. return checkNodeRule(fucusedNode) == true ? fucusedNode : null;
     
157. return null;
     
158. }
     
159. /// <summary>
     
160. /// 水平滚动条
     
161. /// </summary>
     
162. /// <param name="tree">TreeList</param>
     
163. public static void HorzScroll(this TreeList tree)
     
164. {
     
165. if (tree == null)
     
166. throw new ArgumentNullException("tree");
     
167. tree.OptionsView.AutoWidth = false;
     
168. tree.BestFitColumns();
     
169. tree.HorzScrollVisibility = ScrollVisibility.Always;
     
170. }
     
171. /// <summary>
     
172. /// 为TreeList附加右键菜单
     
173. /// MouseUp(object sender, MouseEventArgs e)事件中调用
     
174. /// </summary>
     
175. /// <param name="tree">TreeList</param>
     
176. /// <param name="e">MouseEventArgs</param>
     
177. /// <param name="menu">PopupMenu</param>
     
178. /// <param name="attachMenuRule">AttachMenuRule</param>
     
179. public static void AttachMenu(this TreeList tree, MouseEventArgs e, PopupMenu menu, Func<TreeListNode, bool> attachMenuRule)
     
180. {
     
181. if (tree == null)
     
182. throw new ArgumentNullException("tree");
     
183. if (menu == null)
     
184. throw new ArgumentNullException("menu");
     
185. if (e.Button == MouseButtons.Right && Control.ModifierKeys == Keys.None && tree.State == TreeListState.Regular)
     
186. {
     
187. Point _point = new Point(Cursor.Position.X, Cursor.Position.Y);
     
188. TreeListHitInfo _hitInfo = tree.CalcHitInfo(e.Location);
     
189. if (_hitInfo.HitInfoType == HitInfoType.Cell)
     
190. tree.SetFocusedNode(_hitInfo.Node);
     
191. if (attachMenuRule(tree.FocusedNode))
     
192. menu.ShowPopup(_point);
     
193. }
     
194. }
     
195. /// <summary>
     
196. /// 设置父节点的状态AfterCheckNode(object sender, NodeEventArgs e)
     
197. /// </summary>
     
198. /// <param name="node"></param>
     
199. /// <param name="check"></param>
     
200. public static void ProcessNodeCheckState(this TreeListNode node, CheckState check)
     
201. {
     
202. if (node == null)
     
203. throw new ArgumentNullException("node");
     
204. SetCheckedChildNodes(node, check);
     
205. SetCheckedParentNodes(node, check);
     
206. }
     
207. /// <summary>
     
208. /// 设置子节点CheckState
     
209. /// </summary>
     
210. /// <param name="node"></param>
     
211. /// <param name="check"></param>
     
212. private static void SetCheckedChildNodes(TreeListNode node, CheckState check)
     
213. {
     
214. if (node != null)
     
215. {
     
216. node.LoopTreeNodes((TreeListNode _node) =>
     
217. {
     
218. _node.CheckState = check;
     
219. });
     
220. }
     
221. }
     
222. /// <summary>
     
223. /// 设置父节点CheckState
     
224. /// </summary>
     
225. /// <param name="node"></param>
     
226. /// <param name="check"></param>
     
227. private static void SetCheckedParentNodes(TreeListNode node, CheckState check)
     
228. {
     
229. if (node.ParentNode != null)
     
230. {
     
231. bool _checkStatus = false;
     
232. CheckState _nodeState;
     
233. node.LoopTreeNodes_Break((TreeListNode _node) =>
     
234. {
     
235. _nodeState = _node.CheckState;
     
236. if (!check.Equals(_nodeState))
     
237. {
     
238. _checkStatus = !_checkStatus;
     
239. return false;//跳出循环
     
240. }
     
241. return true;//继续循环
     
242. });
     
243. node.ParentNode.CheckState = _checkStatus ? CheckState.Indeterminate : check;
     
244. SetCheckedParentNodes(node.ParentNode, check);
     
245. }
     
246. }
     
247. /// <summary>
     
248. /// 根据CheckState获取TreeListNode
     
249. /// </summary>
     
250. /// <param name="tree">TreeList</param>
     
251. /// <param name="state">CheckState</param>
     
252. /// <param name="GetNodesByStateRule">返回True的时候继续</param>
     
253. /// <returns>TreeListNode集合</returns>
     
254. public static List<TreeListNode> GetNodesByState(this TreeList tree, CheckState state, Func<TreeListNode, bool> GetNodesByStateRule)
     
255. {
     
256. if (tree == null)
     
257. throw new ArgumentNullException("tree");
     
258. List<TreeListNode> _checkNodes = new List<TreeListNode>();
     
259. tree.LoopTree((TreeListNode node) =>
     
260. {
     
261. if (GetNodesByStateRule(node))
     
262. {
     
263. if (node.CheckState == state)
     
264. _checkNodes.Add(node);
     
265. }
     
266. });
     
267. return _checkNodes;
     
268. }
     
269. }
     
270. }

复制代码

本文实例备有详尽的注释，可以帮助大家更好的加以理解。

写的很好

学习了，写的不错