在C#应用中，设计自己的配置文件

在系统开发的过程中，我们总是需要使用配置文件来保存一些我们需要保存的系统参数，毕竟这是.Net时代，如果再使用注册表那就显得复杂了，毕竟操作注册表的API并不是哪么容易理解的。<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

所以在.net应用程序中，都默认出现一个App.Config（对于 Web应用程序是Web.Config）我们可以将系统运行所需要的参数采用加密或者明文的方式保存在这个文件中。但是当我们需要大量的，并且有一定逻辑结构的数据，希望也能够保存到配置文件中，此时我们可能这样做：将这些数据构造成DataSet，然后使用DataSet.WriteXML直接写成XML文件，读取的时候直接使用DataSet.LoadXML。另外一种方式就是直接操作XML数据，使用XmlDocument。

第一种方法虽然是好，因为我们可以想操作数据库表一样操作我们的结构化的数据，可是在某些情况下，总觉得怪怪的。并且增加列等等这些的操作觉得及其难受。特别是我们需要使用这些数据的时候，我们首先要去读文档，了解DataSet中的每个表以及每个字段的含义，所以此方法不可取。

那第二种方法呢，这个更不可取。如果我们增加了某个字段，或者修改了数据的机构，那我们的代码修改起来是在也是比较复杂的事情。

那有什么更好的方式来解决这个问题的呢？

既然微软可以使用App.Config和Web.Config，可以使用ComfigManager来对这两个配置文件来进行管理，让我们非常方便地进行使用，那我们为何不可设计自己的ConfigManager呢？

需求：我们这里以菜单结构作为例子来描述我们的想法。

菜单，包括主菜单项，比如系统里面的“文件”，“编辑”等等，包括子菜单，比如“文件”下的“保存”，“另存为”等，子菜单下也包括下级子菜单。总之这是一个完全结构化的数据格式，当然使用菜单来举例主要是这东西我们每天都见到，所以很容易理解，如：

1. publicclassMenu
2. {
3. privatestring_Name;
4. privatestring_Text;
5. privatestring_IconName;
6. //...这里可能还有其他你需要变量
7. privateSubMenus_SubMenus;
9. ///<summary>
10. ///注意，一定需要一个无参数的构造函数，否则序列化的时候出错
11. ///</summary>
12. publicMenu()
13. :this("","","")
14. {}
16. publicMenu(stringname,stringtext,stringiconname)
17. {
18. this._Name=name;
19. this._Text=text;
20. this._IconName=iconname;
22. this._SubMenus=newSubMenus();
23. }
25. ///<summary>
26. ///菜单名
27. ///</summary>
28. [XmlAttribute("Name")]
29. publicstringName
30. {
31. get{returnthis._Name;}
32. set{this._Name=value;}
33. }
34. ///<summary>
35. ///菜单Text
36. ///</summary>
37. [XmlAttribute("Text")]
38. publicstringText
39. {
40. get{returnthis._Text;}
41. set{this._Text=value;}
42. }
43. ///<summary>
44. ///菜单的图标名
45. ///</summary>
46. [XmlAttribute("IconName")]
47. publicstringIconName
48. {
49. get{returnthis._IconName;}
50. set{this._IconName=value;}
51. }
52. ///<summary>
53. ///子菜单
54. ///</summary>
55. publicSubMenusSubMenus
56. {
57. get{returnthis._SubMenus;}
58. set{this._SubMenus=value;}
59. }
60. }

好，那我们菜单项包括子菜单，怎么表示呢？

我们使用一个List来保存我们的子菜单，为了更为直观，我们定义一个SubMenus的类，继承于List<Menu>

1. ///<summary>
2. ///子菜单列表
3. ///</summary>
4. publicclassSubMenus:List<Menu>
5. {
6. }

下面我们就来构造我们的菜单MenuStrip。一个MenuStrip中，同样包括多个菜单，比如“文件”“编辑”“视图”等等。

在MenuStrip中，我们提供Load()函数，用于加载我们的菜单数据，提供Save()用于保存我们设置好的菜单数据：

1. publicclassMenuStrip
2. {
3. //...您需要的其他变量
4. privateSubMenus_SubMenus;
6. publicMenuStrip()
7. {
8. this._SubMenus=newSubMenus();
9. }
11. publicSubMenusSubMenus
12. {
13. get{returnthis._SubMenus;}
14. set{this._SubMenus=value;}
15. }
17. ///<summary>
18. ///这里使用Static，方便调用
19. ///</summary>
20. ///<returns></returns>
21. publicMenuStripLoad()
22. {
23. MenuStripinstance=newMenuStrip();
24. XmlSerializerxs=newXmlSerializer(typeof(MenuStrip));
25. StreamReadersr=newStreamReader(@"...\Menu.Config");
26. instance=xs.Deserialize(sr)asMenuStrip;
28. sr.Close();
30. returninstance;
31. }
33. publicvoidSave()
34. {
35. XmlSerializerxs=newXmlSerializer(typeof(MenuStrip));
36. StreamWritersw=newStreamWriter(@"...\Menu.Config");
37. xs.Serialize(sw,this);
39. sw.Close();
40. }
41. }

测试代码如下：

1. MenuStripmenustrip=newMenuStrip();
3. //文件菜单
4. MenumnuFile=newMenu("mnuFile","文件(&F)","");
5. mnuFile.SubMenus.Add(newMenu("mnuNew","新建",""));
6. mnuFile.SubMenus.Add(newMenu("mnuSave","保存",""));
7. mnuFile.SubMenus.Add(newMenu("mnuSaveAs","另存为",""));
8. menustrip.SubMenus.Add(mnuFile);
10. MenumnuEdit=newMenu("mnuEdit","编辑(&E)","");
11. mnuEdit.SubMenus.Add(newMenu("mnuCopy","复制",""));
12. mnuEdit.SubMenus.Add(newMenu("mnuDelete","删除",""));
13. mnuEdit.SubMenus.Add(newMenu("mnuCut","剪切",""));
14. menustrip.SubMenus.Add(mnuEdit);
16. menustrip.SubMenus.Add(newMenu("mnuView","视图(&V)",""));
17. menustrip.Save();

上面的代码构造了一个配置文件，保存后结果如下：

1. <?xmlversion="1.0"encoding="utf-8"?>
2. <MenuStripxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:xsd="http://www.w3.org/2001/XMLSchema">
3. <SubMenus>
4. <MenuName="mnuFile"Text="文件(&F)"IconName="">
5. <SubMenus>
6. <MenuName="mnuNew"Text="新建"IconName="">
7. <SubMenus/>
8. </Menu>
9. <MenuName="mnuSave"Text="保存"IconName="">
10. <SubMenus/>
11. </Menu>
12. <MenuName="mnuSaveAs"Text="另存为"IconName="">
13. <SubMenus/>
14. </Menu>
15. </SubMenus>
16. </Menu>
17. <MenuName="mnuEdit"Text="编辑(&E)"IconName="">
18. <SubMenus>
19. <MenuName="mnuCopy"Text="复制"IconName="">
20. <SubMenus/>
21. </Menu>
22. <MenuName="mnuDelete"Text="删除"IconName="">
23. <SubMenus/>
24. </Menu>
25. <MenuName="mnuCut"Text="剪切"IconName="">
26. <SubMenus/>
27. </Menu>
28. </SubMenus>
29. </Menu>
30. <MenuName="mnuView"Text="视图(&V)"IconName="">
31. <SubMenus/>
32. </Menu>
33. </SubMenus>
34. </MenuStrip>

您可能会说，这样也不见得很好啊，但是你是否发现，我们就像使用菜单对象一样来操作我们的Menu对象，我们不需要像使用DataSet那样首先要去了解其中每个数据库表的每个字段的含义，也不需要像使用XmlDocument那样去记住每个菜单项的位置。菜单项就是我们的Menu对象，我们可以增加不限级的子菜单，随意遍历我们的菜单等等。

另，通过这样的方式，可以在我们的应用中设计各种各样易于使用修改和维护的结构。