Generic config section handlers

Yan Cui

I help clients go faster for less using serverless technologies.

This article is brought to you by

Is your CI build step taking too long? Try Depot for free today and experience up to 40x faster build speed!

Unlock faster CI for FREE

It’s been a while since I had to create a config section handler and my god did I forget how cumbersome a process it is!

Instead of doing all these work to make a bespoke config section handler every time you want to parse some data out of the app.config file, wouldn’t it be nice to have a more generic, reusable component to do all the work for you? Well, turns out it wasn’t all that hard to make one either!

Broadly speaking, you usually want to parse either an object, or a collection of objects out of the config file, and they required slightly different handling so I ended up writing one for each.

Single Object

The single object case is fairly easy, all you need is an XmlSerializer for deserializing the XML node:

   1: public sealed class GenericConfigSectionHandler<T> : IConfigurationSectionHandler

   2: {

   3:     public object Create(object parent, object configContext, XmlNode section)

   4:     {

   5:         var xmlSerializer = new XmlSerializer(typeof(T));

   6:         var xmlNodeReader = new XmlNodeReader(section);

   7:         return xmlSerializer.Deserialize(xmlNodeReader);

   8:     }

   9: }

Assuming you have a simple class like this:

   1: [XmlRoot("MyClass")]

   2: public class MyClass

   3: {

   4:     public string Name { get; set; }


   6:     public int Age { get; set; }

   7: }

To parse it out of your app.config file, you need something like this in the config file:

   1: <configuration>

   2:   <configSections>

   3:     <section name="MyClass"

   4:              type="ConsoleApplication.GenericConfigSectionHandler`1[[ConsoleApplication.MyClass, ConsoleApplication]], ConsoleApplication"/>

   5:   </configSections>


   7:   <MyClass>

   8:     <Name>Yan</Name>

   9:     <Age>29</Age>

  10:   </MyClass>

  11: <configuration>

And your code will be the same as before:

   1: var myObj = (MyClass)ConfigurationManager.GetSection("MyClass");


Collections usually represent a whole new level of pain because to get an array of objects out of the config file you have to first create a wrapper object to hold the array. You then need to set up your config section to parse the wrapper object instead of the array itself, just an additional hoop you have to jump through to get something simple done…

Well, with this GenericCollectionConfigSectionHandler class hopefully you won’t ever have to do that again!

   1: public sealed class GenericCollectionConfigSectionHandler<T> : IConfigurationSectionHandler

   2: {

   3:     static GenericCollectionConfigSectionHandler()

   4:     {

   5:         // get the XmlRootAttribute element on the type

   6:         var type = typeof(T);

   7:         var xmlRootAttributes =

   8:             type.GetCustomAttributes(typeof(XmlRootAttribute), false)

   9:                 .OfType<XmlRootAttribute>();


  11:         // if an XmlRootAttribute is found then use its ElementName property as the

  12:         // root element name for the type T, otherwise, use the name of the type T

  13:         // as the default root element name

  14:         RootElementName =

  15:             !xmlRootAttributes.Any()

  16:                 ? type.Name

  17:                 : xmlRootAttributes.First().ElementName;

  18:     }


  20:     private static string RootElementName { get; set; }


  22:     public object Create(object parent, object configContext, XmlNode section)

  23:     {

  24:         var xmlSerializer = new XmlSerializer(typeof(T));

  25:         var xmlNodeReader = new XmlNodeReader(section);

  26:         var xdoc = XDocument.Load(xmlNodeReader);

  27:         var items =

  28:             xdoc.Descendants(RootElementName)

  29:                 .Select(e => (T)xmlSerializer.Deserialize(e.CreateReader()));

  30:         return items.ToArray();

  31:     }

  32: }

As you can see, this class is pretty simple, to use it your config file ought to look a little like this:

   1: <configuration>

   2:   <configSections>

   3:     <section name="MyClasses"

   4:              type="ConsoleApplication.GenericCollectionConfigSectionHandler`1[[ConsoleApplication.MyClass, ConsoleApplication]], ConsoleApplication"/>

   5:   </configSections>


   7:   <MyClasses>

   8:     <MyClass>

   9:       <Name>Yan</Name>

  10:       <Age>29</Age>

  11:     </MyClass>

  12:     <MyClass>

  13:       <Name>Yinan</Name>

  14:       <Age>29</Age>

  15:     </MyClass>

  16:   </MyClasses>

  17: </configuration>

So you see, no wrapper class required and you get an array of MyClass instances back:

   1: var myObjs = (MyClass[])ConfigurationManager.GetSection("MyClasses");

Whenever you’re ready, here are 4 ways I can help you:

  1. Production-Ready Serverless: Join 20+ AWS Heroes & Community Builders and 1000+ other students in levelling up your serverless game. This is your one-stop shop for quickly levelling up your serverless skills.
  2. Do you want to know how to test serverless architectures with a fast dev & test loop? Check out my latest course, Testing Serverless Architectures and learn the smart way to test serverless.
  3. I help clients launch product ideas, improve their development processes and upskill their teams. If you’d like to work together, then let’s get in touch.
  4. Join my community on Discord, ask questions, and join the discussion on all things AWS and Serverless.

4 thoughts on “Generic config section handlers”

  1. Oops, posted this on the wrong post.

    I used this a while ago and it was fan­tas­tic. Gen­er­ated all the cs and even an exam­ple .con­fig. How­ever it seems to have fallen in to disrepute.



  2. theburningmonk

    Hey Ian, how’s it going? How everything’s well with you and Mel. I had a look at that project in the past too, didn’t end up using it in any of our stuffs but it did look pretty cool.

    What have you been up to these days? Have you finished working on EyePatch?

  3. Some Guy Somewhere

    Nice. One question: Why sealed? Why not abstract, so you can make a new class inherited from a typed version of this generic for easier reading in the config file? Something like this:

    public abstract class GenericConfigurationSectionHandler : IConfigurationSectionHandler where TConfigModel : class

    so you can then do something like this:

    public class FooHandler : GenericConfigurationSectionHandler

    and your config could look like this:

Leave a Comment

Your email address will not be published. Required fields are marked *