是否可以从外部文件初始化ConfigurationSection？

Question

I have a custom configuration property in my app. It looks something like this:

public class OverrideConfiguration : ConfigurationSection
{
    [ConfigurationProperty(PROP_ADMIN_CONNSTR)]
    public StringConfigurationElement AdminConnectionString
    {
        get { return base[PROP_ADMIN_CONNSTR] as StringConfigurationElement; }
        set { base[PROP_ADMIN_CONNSTR] = value; }
    }

    // .. Various other properties, but you get the idea
}

However, what I'd like is to allow the .config file to be pointed to an external file source. Something like this:

<ServiceOverrides file="Overrides.local.config" />

Now, the built-in configSource attribute is close to what I need, but it has two major issues.

1. Files must exist. If the file doesn't exist, it errors out.
2. Files must be in the current directory or in a deeper directory. In other words, I can't point to ..\\Overrides.local.config

What I want is pretty much identical to the <appSettings file="..." /> configuration element. However, that attribute seems to be something appSettings implemented, and is not part of the base ConfigurationSection class.

My Question:

Is it possible to override something in ConfigurationSection that will basically read XML data from a different location? I don't want to change any other aspect of my class or do my own XML deserialization or anything. I simply want to check if a file exists, if so, load in the XML contents from that file, otherwise load in the default XML contents.

Answer 1

Ok, I have a working solution. I'm not sure if it's the best approach, but it does appear to work exactly how I want.

private readonly Queue<String> externalSources = new Queue<String>();

protected override void DeserializeElement(XmlReader reader, bool serializeCollectionKey)
{
    var externalFile = reader.GetAttribute("File");
    if(!String.IsNullOrWhiteSpace(externalFile))
    {
        externalSources.Enqueue(externalFile);
    }

    base.DeserializeElement(reader, serializeCollectionKey);
}

protected override void PostDeserialize()
{
    base.PostDeserialize();

    // Override data with local stuff
    if (externalSources.Count == 0) return;

    string file = externalSources.Dequeue();
    if (System.IO.File.Exists(file))
    {
        var reader = XmlReader.Create(file);
        base.DeserializeSection(reader);
    }
}

First, I trap the DeserializeElement event, which happens when we read the <ServiceOverrides> element. We check if it has a File attribute, and if so we add it to a queue of external sources to load.

Next, we trap the PostDeserialize event, which gets called after all the local XML is parsed. If there's an external source in the queue, we dequeue it, check if it actually exists, then create an XmlReader with the contents of that file. Now we can simply call DeserializeSection again and pass in our new reader. The ConfigurationSection class is smart enough to just overwrite or append any new data to the existing configuration. What I get at the end is an aggregation of both configuration files, where the include file wins in the event of a duplicate.

Now, what's this nonsense with the queue? Well, it seems every time you call DeserializeSection , it'll call PostDeserialize again. So, if we simply trapped PostDeserialize , check the File attribute, and call DeserializeSection again, we'd get in an infinite loop. We could just use a flag to remember if we already loaded the external file, but a queue has the added benefit of allowing the include file to load more include files (not that I'd ever want to do that, but you might).

Tips: This will probably work fairly well, and is simple to understand, but if you're using it in production code, there's a few things you could improve on. First, externalSources doesn't really need to be a queue, since these calls aren't actually recursive. You can probably just use a string , and set it to null after you're done processing that file. Second, this could cause an infinite loop in the event of a circular include chain. You could create a List<T> of previously included files, then check if the include already exists in that list before adding it to the queue.

Hope this helps someone!