TreeView序列化，TreeView串行化，TreeView反序列化 c# winform

2009年给公司做了个管理系统，里面用到了TreeView，数据有1500多条，加载要10秒钟左右

柳永法(yongfa365)'Blog的特点是：有问题，就要解决，尤其是像这种几十人、上百人使用的系统。

后来使用登录时加载数据，登录后再使用就Clone()的解决方案，感觉不错。

不过，每次调试程序时得等半天，实在不爽。

前些天看到“序列化”这个概念，大意就是把对象保存为一个文件，下次再使用时，反序列化一下就OK了，第二天一大早到公司立马做了个Demo,哇，不错，非常之不错，使用此方法后，根本没有延迟的现象。今天终于应用到这个项目中了，同志们再也不用等那10秒了。

特记录于此，供后人瞻仰

view plain copy to clipboard print ?

1. using System;   
2. using System.IO;   
3. using System.Windows.Forms;   
4. using System.Runtime.Serialization.Formatters.Binary;   
5. using System.Data;   
6.   
7. //from:http://www.ecjtu.org/forum/read.php?tid-12933.html   
8. //反序列化：SerializeTree.TreeViewDataAccess.LoadTreeViewData(treeView1,"C:\\treeview.txt");   
9. //序列化：  SerializeTree.TreeViewDataAccess.SaveTreeViewData(treeView1,"C:\\treeview.txt");   
10.   
11.   
12. namespace SerializeTree   
13. {   
14.     /// <summary>   
15.     /// TreeView串行化类   
16.     /// </summary>   
17.     public class TreeViewDataAccess   
18.     {   
19.         public TreeViewDataAccess() { }   
20.   
21.         /// <summary>   
22.         /// TreeViewData   
23.         /// </summary>   
24.         [Serializable()]   
25.         public struct TreeViewData   
26.         {   
27.             public TreeNodeData[] Nodes;   
28.   
29.             /// <summary>   
30.             /// 递归初始化TreeView数据   
31.             /// </summary>   
32.             /// <param name="treeview"></param>   
33.             public TreeViewData(TreeView treeview)   
34.             {   
35.                 Nodes = new TreeNodeData[treeview.Nodes.Count];   
36.                 if (treeview.Nodes.Count == 0)   
37.                 {   
38.                     return;   
39.                 }   
40.                 for (int i = 0; i <= treeview.Nodes.Count - 1; i++)   
41.                 {   
42.                     Nodes[i] = new TreeNodeData(treeview.Nodes[i]);   
43.                 }   
44.             }   
45.   
46.             /// <summary>   
47.             /// 通过TreeViewData弹出TreeView   
48.             /// </summary>   
49.             /// <param name="treeview"></param>   
50.             public void PopulateTree(TreeView treeview)   
51.             {   
52.                 if (this.Nodes == null || this.Nodes.Length == 0)   
53.                 {   
54.                     return;   
55.                 }   
56.                 treeview.BeginUpdate();   
57.                 for (int i = 0; i <= this.Nodes.Length - 1; i++)   
58.                 {   
59.                     treeview.Nodes.Add(this.Nodes[i].ToTreeNode());   
60.                 }   
61.                 treeview.EndUpdate();   
62.             }   
63.         }   
64.   
65.         /// <summary>   
66.         /// TreeNodeData   
67.         /// </summary>   
68.         [Serializable()]   
69.         public struct TreeNodeData   
70.         {   
71.             public string Text;   
72.             public int ImageIndex;   
73.             public int SelectedImageIndex;   
74.             public bool Checked;   
75.             public bool Expanded;   
76.             public object Tag;   
77.             public TreeNodeData[] Nodes;   
78.   
79.             /// <summary>   
80.             /// TreeNode构造函数   
81.             /// </summary>   
82.             /// <param name="node"></param>   
83.             public TreeNodeData(TreeNode node)   
84.             {   
85.                 this.Text = node.Text;   
86.                 this.ImageIndex = node.ImageIndex;   
87.                 this.SelectedImageIndex = node.SelectedImageIndex;   
88.                 this.Checked = node.Checked;   
89.                 this.Expanded = node.IsExpanded;   
90.                 this.Nodes = new TreeNodeData[node.Nodes.Count];   
91.   
92.                 if ((!(node.Tag == null)) && node.Tag.GetType().IsSerializable)   
93.                 {   
94.                     this.Tag = node.Tag;   
95.                 }   
96.                 else  
97.                 {   
98.                     this.Tag = null;   
99.                 }   
100.                 if (node.Nodes.Count == 0)   
101.                 {   
102.                     return;   
103.                 }   
104.                 for (int i = 0; i <= node.Nodes.Count - 1; i++)   
105.                 {   
106.                     Nodes[i] = new TreeNodeData(node.Nodes[i]);   
107.                 }   
108.             }   
109.   
110.             /// <summary>   
111.             /// TreeNodeData返回TreeNode   
112.             /// </summary>   
113.             /// <returns></returns>   
114.             public TreeNode ToTreeNode()   
115.             {   
116.                 TreeNode ToTreeNode = new TreeNode(this.Text, this.ImageIndex, this.SelectedImageIndex);   
117.                 ToTreeNode.Checked = this.Checked;   
118.                 ToTreeNode.Tag = this.Tag;   
119.                 if (this.Expanded)   
120.                 {   
121.                     ToTreeNode.Expand();   
122.                 }   
123.                 if (this.Nodes == null && this.Nodes.Length == 0)   
124.                 {   
125.                     return null;   
126.                 }   
127.                 if (ToTreeNode != null && this.Nodes.Length == 0)   
128.                 {   
129.                     return ToTreeNode;   
130.                 }   
131.                 for (int i = 0; i <= this.Nodes.Length - 1; i++)   
132.                 {   
133.                     ToTreeNode.Nodes.Add(this.Nodes[i].ToTreeNode());   
134.                 }   
135.                 return ToTreeNode;   
136.             }   
137.         }   
138.         /// <summary>   
139.         /// 加载TreeView   
140.         /// </summary>   
141.         /// <param name="treeView"></param>   
142.         /// <param name="path"></param>   
143.         public static void LoadTreeViewData(TreeView treeView, string path)   
144.         {   
145.   
146.             BinaryFormatter ser = new BinaryFormatter();   
147.             Stream file = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);   
148.             TreeViewData treeData = ((TreeViewData)(ser.Deserialize(file)));   
149.             treeData.PopulateTree(treeView);   
150.             file.Close();   
151.   
152.         }   
153.   
154.         /// <summary>   
155.         /// 保存TreeView到文件   
156.         /// </summary>   
157.         /// <param name="treeView"></param>   
158.         /// <param name="path"></param>   
159.         public static void SaveTreeViewData(TreeView treeView, string path)   
160.         {   
161.             BinaryFormatter ser = new BinaryFormatter();   
162.             Stream file = new FileStream(path, FileMode.Create);   
163.             ser.Serialize(file, new TreeViewData(treeView));   
164.             file.Close();   
165.   
166.         }   
167.     }   
168.   
169.     //柳永法加的，序列化，及反序列化DataTable   
170.     class SerializeDataTable   
171.     {   
172.         public static DataTable LoadDataTable(string path)   
173.         {   
174.   
175.             BinaryFormatter ser = new BinaryFormatter();   
176.             Stream file = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);   
177.             DataTable dt = (DataTable)ser.Deserialize(file);   
178.             file.Close();   
179.             return dt;   
180.         }   
181.   
182.         public static void SaveDataTable(DataTable dt, string path)   
183.         {   
184.             BinaryFormatter ser = new BinaryFormatter();   
185.             Stream file = new FileStream(path, FileMode.Create);   
186.             ser.Serialize(file, dt);   
187.             file.Close();   
188.   
189.         }   
190.     }   
191.   
192. }