如何自定义配置节点

目录

• 自定义配置节点中相关类的介绍
• 自定义配置单节点
• 自定义配置多节点
• 使用实现接口方式来自定义配置节点

• 自定义配置节点中相关类的介绍 (返回)
• 自定义配置单节点 (返回)

1. 向项目中添加System.Configuration引用。ConfigurationSection、ConfigurationElement、ConfigurationElementCollection这几个类都是在System.Configuration中定义的，而该dll默认并不是新建一个项目就有的，需要添加该dll引用。
2. 假如我们要配置的节点格式如下：

1. <?xml version="1.0" encoding="utf-8" ?>
2. <configuration>
3.   <configSections>
4.       <section name="SingleSectionHandler" type="CustomSingleSection.SingleSectionHandler, CustomSingleSection, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
5.   </configSections>
7.   <SingleSectionHandler myAttrib1="lastBeachhead">
8.     <MySingleSection MyAttribute1="softwarezxj" MyAttribute2="epms"/>
9.    </SingleSectionHandler>
11. </configuration>

    从配置信息可以看出，我们需要实现一个类CustomSingleSection.SingleSectionHandler，该类有2个属性，一个属性类型为string,名称为myAttrib1,另外一个属性类型为MySingleSection，类型MySingleSection有2个string类型的属性。因为MySingleSection下并没有子节点，故该类需要继承自CongigurationElement,而SingleSectionHandler因为是一个section,所以该类需要继承自System.ConfigurationSection。
    具体的实现代码如下：

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Configuration;
7. namespace CustomSingleSection
8. {
9.     public class SingleSectionHandler : ConfigurationSection
10.     {
11.         public SingleSectionHandler()
12.         {
13.         }
14.         public SingleSectionHandler(String attribVal)
15.         {
16.             MyAttrib1 = attribVal;
17.         }
19.         [ConfigurationProperty("myAttrib1", DefaultValue = "默认值", IsRequired = true)]
20.         [StringValidator(InvalidCharacters = "~!@#$%^&*()[]{}/;'/"|//", MinLength = 1, MaxLength = 60)]
21.         public String MyAttrib1
22.         {
23.             get { return (String)this["myAttrib1"]; }
24.             set { this["myAttrib1"] = value; }
25.         }
27.         [ConfigurationProperty("MySingleSection")]
28.         public MySingleSection MySingleSection
29.         {
30.             get
31.             {
32.                 return (MySingleSection)this["MySingleSection"]; 
33.             }
34.             set
35.             {
36.                 this["MySingleSection"] = value; 
37.             }
38.         }
39.     }
41.     public class MySingleSection : ConfigurationElement 
42.     {
43.         public MySingleSection()
44.         {
45.         }
47.         public MySingleSection(String a1, String a2)
48.         {
49.             MyAttribute1 = a1;
50.             MyAttribute2 = a2;
51.         }
53.         [ConfigurationProperty("MyAttribute1", DefaultValue = "默认属性1", IsRequired = true)]
54.         [StringValidator(InvalidCharacters = "~!@#$%^&*()[]{}/;'/"|//", MinLength = 1, MaxLength = 60)]
55.         public String MyAttribute1
56.         {
57.             get{ return (String)this["MyAttribute1"]; }
58.             set{ this["MyAttribute1"] = value; }
59.         }
61.         [ConfigurationProperty("MyAttribute2", DefaultValue = "默认属性2", IsRequired = true)]
62.         [StringValidator(InvalidCharacters = "~!@#$%^&*()[]{}/;'/"|//", MinLength = 1, MaxLength = 60)]
63.         public String MyAttribute2
64.         {
65.             get{ return (String)this["MyAttribute2"]; }
66.             set{ this["MyAttribute2"] = value; }
67.         }
69.     }
70. }

   从代码里可以看出了各个基类本身已经有了索引器。另外需要注意的是，配置的信息都是大小写敏感的。比如我们在类SingleSectionHandler中定义了属性MyAttrib1的标签[ConfigurationProperty("myAttrib1", DefaultValue = "默认值", IsRequired = true)]，那么在config文件中属性的名字就必须是myAttrib1,大小写不能写错，而且MyAttrib1属性的实现中，使用索引器的时候也必须是get { return (String)this["myAttrib1"]; } set { this["myAttrib1"] = value; },索引器中的键名如果不是myAttrib1,即跟config中的属性名称不一样，那也是运行不成功的。
   使用该配置的代码如下：

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Configuration;
7. namespace CustomSingleSection
8. {
9.     class Program
10.     {
11.         static void Main(string[] args)
12.         {
13.             LookCustomSingleSection();
14.             Console.ReadLine();
15.         }
17.         private static void LookCustomSingleSection() 
18.         {
19.             SingleSectionHandler mySingleSection = ConfigurationManager.GetSection("SingleSectionHandler") as SingleSectionHandler;
20.             StringBuilder sb = new StringBuilder();
22.             sb.Append("该自定义配置节的属性MyAttrib1的值是：");
23.             sb.Append(mySingleSection.MyAttrib1.ToString());
24.             sb.Append("/n");
26.             sb.Append("该自定义配置节的MySingleConfigElement节点的MyAttribute1属性的值是：");
27.             sb.Append( mySingleSection.MySingleSection.MyAttribute1.ToString() );
28.             sb.Append("/n");
30.             sb.Append("该自定义配置节的MySingleConfigElement节点的MyAttribute2属性的值是：");
31.             sb.Append(mySingleSection.MySingleSection.MyAttribute2.ToString());
32.             sb.Append("/n");
34.             Console.WriteLine( sb.ToString() );
35.         }
37.     }
39. }

• 自定义配置多节点 (返回)

   举例说明，假如我们需要实现一个如下的配置：

1. <customMulSectionDemo>
2.     <regexUrlMapping enable="true" rebaseClientPath="true">
3.       <add url="(/d+)$" mappedUrl="default.aspx?id=$1"></add>
4.       <add url="/$" mappedUrl="default.aspx?id=0"></add>
5.     </regexUrlMapping>
6. </customMulSectionDemo>

    在这里customMulSectionDemo就是我们要定义的配置节，而配置节里面又包含一个regexUrlMapping元素，该元素有两个属性和一些子元素，我们选择的子元素比较特殊，它是n个add元素。使用的形式跟assSettings元素下面的add元素类似。那么如何实现这个自定义配置呢？
    首先需要定义一个配置节元素，如下：

1. <configSections>
2.     <section name="customMulSectionDemo" type="CustomMulSection.RegexUrlMappingConfig,CustomMulSection" allowDefinition="Everywhere" restartOnExternalChanges="true" allowLocation="true"/>
3. </configSections>

    在这里，我们只讲解name和type属性的使用，其它属性的用法请参阅MSDN。name属性表示自定义配置节元素的名称。Type表示应该由哪个dll下哪个命名空间的哪个类来处理这个配置节。如上例中所写，CustomMulSection是dll的名称(可以从AssemblyInfo.cs文件中找到)，CustomMulSection.RegexUrlMappingConfig是处理该配置节的类的全名称（包含命名空间）。
    Ok，我们已经把目的明确了，下面的工作就是要实现RegexUrlMappingConfig这个类。要想此类拥有处理配置节的能力，就必须装饰一下这个类，装饰完成后，此类的代码如下：

1. class RegexUrlMappingConfig : ConfigurationSection
2.     {
3.         [ConfigurationProperty("regexUrlMapping")]
4.         public UrlMappingCollection UrlMappings
5.         {
6.             get{return this["regexUrlMapping"] as UrlMappingCollection;}
7.         }
8.     }

    首先，我们的类应该从ConfigurationSection类继承。这样它就有了处理自定义配置信息的能力。由于我们的配置节中只有一个regexUrlMapping元素，而且此元素包含了很多add元素。这种情况下我们使用了一个名为UrlMappings的属性来表示这个集合。为了表示该属性和元素之间的映射关系，我们需要以ConfigurationProperty自定义属性修饰UrlMappings。ConfigurationProperty类的参数” regexUrlMapping”指定了要映射的元素。get访问器中的代码非常程式化，这里不讲它的原理，只需要知道如此就可以实现对数据的访问。
    下一步，就是实现UrlMappingCollection类。由名字可以得知，这是一个集合类，它一般用来处理包含add元素的元素。实现此类也需要使用自定义属性对此类进行装饰。如下：

1. class UrlMappingCollection : ConfigurationElementCollection
2.     {
3.         protected override ConfigurationElement CreateNewElement()
4.         {
5.             return new UrlMapping();
6.         }
7.         protected override object GetElementKey(ConfigurationElement element)
8.         {
9.             return ((UrlMapping)element).Url;
10.         }
12.         [ConfigurationProperty("enable")]
13.         public bool Enable
14.         {
15.             get
16.             {
17.                 return bool.Parse(this["enable"].ToString());
18.             }
19.         }
21.         [ConfigurationProperty("rebaseClientPath")]
22.         public bool RebaseClientPath
23.         {
24.             get
25.             {
26.                 return bool.Parse(this["rebaseClientPath"].ToString());
27.             }
28.         }
30.         //写一个索引器，方便的访问该集合中的元素。
31.         //如果不写，则只有foreach来访问。
32.         public UrlMapping this[int index] 
33.         {
34.             get
35.             {
36.                 return this.BaseGet(index) as UrlMapping;
37.             }
38.         }
40.     }

    可以看到，实现表示集合元素的类必须从ConfigurationElementCollection类继承。并且必须提供CreateNewElement和GetElementKey两个方法的重载。CreateNewElement其实是一个工厂方法，在此方法中，你必须返回一个表示一个add元素的对象，这样系统才能从web.config读取数据并形成一个集合。GetElementKey方法中，你需要返回一个可以表示为add元素键值的属性，方法的参数就是表示add元素的对象，该对象一定是从ConfigurationElement继承的，所以我们可以将其转换为一个我们自定义的配置对象，然后访问它的属性。在示例中我们返回了add元素的url属性值。因为这个方法是拿到一个对象对应的key，所以经常被其它方法调用以获取对象。
    现在，我们已经实现了需要重写的方法。看到regexUrlMapping元素还包括两个属性，实现这两个属性的代码与已讲过的内容类似。在此不做赘述。
    还差最后一步，就是实现表示add元素的类。如下：

1. class UrlMapping : ConfigurationElement
2.     {
3.         [ConfigurationProperty("mappedUrl")]
4.         public string MappedUrl
5.         {
6.             get
7.             {
8.                 return (string)this["mappedUrl"];
9.             }
10.         }
12.         [ConfigurationProperty("url")]
13.         public string Url
14.         {
15.             get
16.             {
17.                 return (string)this["url"];
18.             }
19.         }
20.     }

   唯一需要讲述的就是这个类必须从ConfigurationElement继承。其它的内容通过以上的讲述应该能够很好的理解。
   至此，我们已经完成了配置的映射工作。
   完整的代码如下所示：
   app.config:

1. <?xml version="1.0" encoding="utf-8" ?>
2. <configuration>
3.   <configSections>
4.     <section name="customMulSectionDemo" type="CustomMulSection.RegexUrlMappingConfig,CustomMulSection" allowDefinition="Everywhere" restartOnExternalChanges="true" allowLocation="true"/>
5.   </configSections>
7.   <customMulSectionDemo>
8.     <regexUrlMapping enable="true" rebaseClientPath="true">
9.       <add url="(/d+)$" mappedUrl="default.aspx?id=$1"></add>
10.       <add url="/$" mappedUrl="default.aspx?id=0"></add>
11.     </regexUrlMapping>
12.   </customMulSectionDemo>
13.   
14. </configuration>

   配置相关的解释类：

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Configuration;
7. namespace CustomMulSection
8. {
9.     class RegexUrlMappingConfig : ConfigurationSection
10.     {
11.         [ConfigurationProperty("regexUrlMapping")]
12.         public UrlMappingCollection UrlMappings
13.         {
14.             get{return this["regexUrlMapping"] as UrlMappingCollection;}
15.         }
16.     }
18.     class UrlMappingCollection : ConfigurationElementCollection
19.     {
20.         protected override ConfigurationElement CreateNewElement()
21.         {
22.             return new UrlMapping();
23.         }
24.         protected override object GetElementKey(ConfigurationElement element)
25.         {
26.             return ((UrlMapping)element).Url;
27.         }
29.         [ConfigurationProperty("enable")]
30.         public bool Enable
31.         {
32.             get
33.             {
34.                 return bool.Parse(this["enable"].ToString());
35.             }
36.         }
38.         [ConfigurationProperty("rebaseClientPath")]
39.         public bool RebaseClientPath
40.         {
41.             get
42.             {
43.                 return bool.Parse(this["rebaseClientPath"].ToString());
44.             }
45.         }
47.         //写一个索引器，方便的访问该集合中的元素。
48.         //如果不写，则只有foreach来访问。
49.         public UrlMapping this[int index] 
50.         {
51.             get
52.             {
53.                 return this.BaseGet(index) as UrlMapping;
54.             }
55.         }
57.     }
59.     class UrlMapping : ConfigurationElement
60.     {
61.         [ConfigurationProperty("mappedUrl")]
62.         public string MappedUrl
63.         {
64.             get
65.             {
66.                 return (string)this["mappedUrl"];
67.             }
68.         }
70.         [ConfigurationProperty("url")]
71.         public string Url
72.         {
73.             get
74.             {
75.                 return (string)this["url"];
76.             }
77.         }
78.     }
80. }

   测试代码：

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Configuration;
7. namespace CustomMulSection
8. {
9.     class Program
10.     {
11.         static void Main(string[] args)
12.         {
13.             DealMulSection();
14.             Console.ReadLine();
15.         }
17.         private static void DealMulSection() 
18.         {
19.             RegexUrlMappingConfig myCustomMulSection = ConfigurationManager.GetSection("customMulSectionDemo") as RegexUrlMappingConfig;
20.             StringBuilder sb = new StringBuilder();
22.             sb.Append("myCustomMulSection对象的regexUrlMapping属性(实际是个集合)的enable:");
23.             sb.Append(myCustomMulSection.UrlMappings.Enable.ToString());
24.             sb.Append("/n");
26.             sb.Append("myCustomMulSection对象的regexUrlMapping属性(实际是个集合)的rebaseClientPath:");
27.             sb.Append(myCustomMulSection.UrlMappings.RebaseClientPath.ToString());
28.             sb.Append("/n");
30.             for (int i = 0; i < myCustomMulSection.UrlMappings.Count; i++ )
31.             {
32.                 sb.Append("UrlMappings[");
33.                 sb.Append(i.ToString());
34.                 sb.Append("].url:");
35.                 sb.Append(myCustomMulSection.UrlMappings[i].Url.ToString());
36.                 sb.Append("/n");
38.                 sb.Append("UrlMappings[");
39.                 sb.Append(i.ToString());
40.                 sb.Append("].mappedUrl:");
41.                 sb.Append(myCustomMulSection.UrlMappings[i].MappedUrl.ToString());
42.                 sb.Append("/n");
43.             }
45.             Console.WriteLine(sb.ToString());
46.         }
47.     }
48. }

• 使用实现接口方式来自定义配置节点 (返回)