一个C#序列化TreeView的方法（一个类）

 

1. using System;
2. using System.IO;
3. using System.Windows.Forms;
4. using System.Runtime.Serialization.Formatters.Binary;
6. namespace SerializeTree
7. {
8.     /// <summary>
9.     /// TreeView串行化类
10.     /// </summary>
11.     public class TreeViewDataAccess
12.     {
13.         public TreeViewDataAccess(){}
14.   
15.         /// <summary>
16.         /// TreeViewData
17.         /// </summary>
18.         [Serializable()]
19.         public struct TreeViewData
20.         {
21.             public TreeNodeData[] Nodes;
23.             /// <summary>
24.             /// 递归初始化TreeView数据
25.             /// </summary>
26.             /// <param name="treeview"></param>
27.             public TreeViewData(TreeView treeview)
28.             {
29.                 Nodes = new TreeNodeData[treeview.Nodes.Count];
30.                 if (treeview.Nodes.Count == 0)
31.                 {
32.                     return;
33.                 }
34.                 for (int i = 0; i <= treeview.Nodes.Count - 1; i++) 
35.                 {
36.                     Nodes[i] = new TreeNodeData(treeview.Nodes[i]);
37.                 }
38.             }
40.             /// <summary>
41.             /// 通过TreeViewData弹出TreeView
42.             /// </summary>
43.             /// <param name="treeview"></param>
44.             public void PopulateTree(TreeView treeview)
45.             {
46.                 if (this.Nodes == null || this.Nodes.Length == 0) 
47.                 {
48.                     return;
49.                 }
50.                 treeview.BeginUpdate();
51.                 for (int i = 0; i <= this.Nodes.Length - 1; i++) 
52.                 {
53.                     treeview.Nodes.Add(this.Nodes[i].ToTreeNode());
54.                 }
55.                 treeview.EndUpdate();
56.             }
57.         }
59.         /// <summary>
60.         /// TreeNodeData
61.         /// </summary>
62.         [Serializable()]
63.         public struct TreeNodeData
64.         {
65.             public string Text;
66.             public int ImageIndex;
67.             public int SelectedImageIndex;
68.             public bool Checked;
69.             public bool Expanded;
70.             public object Tag;
71.             public TreeNodeData[] Nodes;
73.             /// <summary>
74.             /// TreeNode构造函数
75.             /// </summary>
76.             /// <param name="node"></param>
77.             public TreeNodeData(TreeNode node)
78.             {
79.                 this.Text = node.Text;
80.                 this.ImageIndex = node.ImageIndex;
81.                 this.SelectedImageIndex = node.SelectedImageIndex;
82.                 this.Checked = node.Checked;
83.                 this.Expanded = node.IsExpanded;
84.                 this.Nodes = new TreeNodeData[node.Nodes.Count];
86.                 if ((!(node.Tag == null)) && node.Tag.GetType().IsSerializable) 
87.                 {
88.                     this.Tag = node.Tag;
89.                 }
90.                 else
91.                 {
92.                     this.Tag = null;
93.                 }
94.                 if (node.Nodes.Count == 0) 
95.                 {
96.                     return;
97.                 }
98.                 for (int i = 0; i <= node.Nodes.Count - 1; i++) 
99.                 {
100.                     Nodes[i] = new TreeNodeData(node.Nodes[i]);
101.                 }
102.             }
104.             /// <summary>
105.             /// TreeNodeData返回TreeNode
106.             /// </summary>
107.             /// <returns></returns>
108.             public TreeNode ToTreeNode()
109.             {
110.                 TreeNode ToTreeNode = new TreeNode(this.Text, this.ImageIndex, this.SelectedImageIndex);
111.                 ToTreeNode.Checked = this.Checked;
112.                 ToTreeNode.Tag = this.Tag;
113.                 if (this.Expanded) 
114.                 {
115.                     ToTreeNode.Expand();
116.                 }
117.                 if (this.Nodes == null && this.Nodes.Length == 0) 
118.                 {
119.                     return null;
120.                 }
121.                 if(ToTreeNode != null && this.Nodes.Length == 0)
122.                 {
123.                     return ToTreeNode;
124.                 }
125.                 for (int i = 0; i <= this.Nodes.Length - 1; i++) 
126.                 {
127.                     ToTreeNode.Nodes.Add(this.Nodes[i].ToTreeNode());
128.                 }
129.                 return ToTreeNode;
130.             }
131.         }
132.         /// <summary>
133.         /// 加载TreeView
134.         /// </summary>
135.         /// <param name="treeView"></param>
136.         /// <param name="path"></param>
137.         public static void LoadTreeViewData(TreeView treeView, string path)
138.         {
140.             BinaryFormatter ser = new BinaryFormatter();
141.             Stream file = new FileStream(path,FileMode.Open,FileAccess.Read,FileShare.Read);
142.             TreeViewData treeData = ((TreeViewData)(ser.Deserialize(file)));
143.             treeData.PopulateTree(treeView);
144.             file.Close();
146.         }
148.         /// <summary>
149.         /// 保存TreeView到文件
150.         /// </summary>
151.         /// <param name="treeView"></param>
152.         /// <param name="path"></param>
153.         public static void SaveTreeViewData(TreeView treeView, string path)
154.         {
155.             BinaryFormatter ser = new BinaryFormatter();
156.             Stream file = new FileStream(path,FileMode.Create);
157.             ser.Serialize(file,new TreeViewData(treeView));
158.             file.Close();
160.         }
161.     }
164. }