Use ConfigurationSection / ConfigurationElementCollection to create a nested collection of items from web.config

Question

I am trying to create a custom section group in my web.config. It is mostly working, but is failing out with the following error:

Unrecognized element 'add'. (web.config line 736) at System.Configuration.BaseConfigurationRecord.EvaluateOne(String[] keys, SectionInput input, Boolean isTrusted, FactoryRecord factoryRecord, SectionRecord sectionRecord, Object parentResult)....

There may be other errors in the code, but this is the part I cannot get passed.

Here is my web.config XML:

Note that I marked the line 736 mentioned in the error.

My class structure is below. The first inherits ConfigurationSection, the second inherits ConfigurationElementCollection, and the last inherits ConfigurationElement. After that is an extension class for the SystemEmailsElement type. It's probably not relevant to the error, but I will include it just for completion sake.

public class SystemEmailsConfiguration : ConfigurationSection
{
    public static SystemEmailsConfiguration GetConfig()
    {
        return ConfigurationManager.GetSection("systemEmailsGroup/systemEmails") as SystemEmailsConfiguration;
    }

    [ConfigurationProperty("emails", IsDefaultCollection = false)]
    [ConfigurationCollection(typeof(SystemEmailsElementCollection), 
        AddItemName = "email", ClearItemsName = "clear", RemoveItemName = "remove")]
    public SystemEmailsElementCollection Emails
    {
        get
        {
            return base["emails"] as SystemEmailsElementCollection;
        }
    }

}

public enum SystemEmailsSource
{
    None = 0,
    UserName = 1,
    RoleName = 2,
    Group = 3
}

public class SystemEmailsElementCollection : ConfigurationElementCollection, IEnumerable
{
    List _elements = new List();

    public SystemEmailsElement this[int index]
    {
        get
        {
            return _elements[index];
        }
        set
        {
            if (index >= 0 && index < _elements.Count)
            {
                _elements.RemoveAt(index);
            }
            _elements.Insert(index, value);
        }
    }

    public SystemEmailsElement this[string key]
    {
        get
        {
            return _elements.Where(e => e.Name == key).FirstOrDefault();
        }
        set
        {
            var el = _elements.Where(e => e.Name == key).FirstOrDefault();
            if (el != null)
            {
                int index = _elements.IndexOf(el);
                _elements.RemoveAt(index);
                _elements.Insert(index, value);
            }
            else
                _elements.Add(value);
        }
    }

    protected override ConfigurationElement CreateNewElement()
    {
        var el = new SystemEmailsElement();
        _elements.Add(el);
        return el;
    }

    protected override object GetElementKey(ConfigurationElement element)
    {
        return _elements.Find(e => e.Equals(element)).Name;
    }

    public new IEnumerator GetEnumerator()
    {
        return _elements.GetEnumerator();
    }
}


public class SystemEmailsElement : ConfigurationElement 
{
    [ConfigurationProperty("name", IsRequired = true, IsKey = true)]
    public string Name
    {
        get
        {
            return this["name"] as string;
        }
    }

    [ConfigurationProperty("source", DefaultValue = SystemEmailsSource.None)]
    public SystemEmailsSource Source
    {
        get
        {
            return (this["source"] != null) ? (SystemEmailsSource)this["source"] : SystemEmailsSource.None;
        }
    }

    [ConfigurationProperty("defaultAddress")]
    public string DefaultAddress
    {
        get
        {
            return this["defaultAddress"] as string;
        }
    }

    [ConfigurationProperty("defaultName")]
    public string DefaultName
    {
        get
        {
            return this["defaultName"] as string;
        }
    }

    [ConfigurationProperty("defaultEmailName")]
    public string DefaultEmailName
    {
        get
        {
            return this["defaultEmailName"] as string;
        }
    }

    [ConfigurationProperty("username")]
    public string UserName
    {
        get
        {
            return this["username"] as string;
        }
    }

    [ConfigurationProperty("rolename")]
    public string RoleName
    {
        get
        {
            return this["rolename"] as string;
        }
    }

    [ConfigurationProperty("email")]
    [ConfigurationCollection(typeof(SystemEmailsElementCollection), 
        AddItemName = "add", ClearItemsName = "clear", RemoveItemName = "remove")]
    public SystemEmailsElementCollection Emails
    {
        get
        {
            return base["email"] as SystemEmailsElementCollection;
        }
    }
}


public static class SystemEmailsElementExtenstions
{
    /// 
    /// Returns true if the SystemEmailsElement may contain a group of email addresses.
    /// 
    /// 
    /// 
    public static bool IsGroup(this SystemEmailsElement value)
    {
        return (value.Source == SystemEmailsSource.Group || value.Source == SystemEmailsSource.RoleName);
    }

    /// 
    /// Gets the email or emails result of this section as a MailAddressCollection.
    /// Returns an empty MailAddressCollection if not able to create any MailAddress objects.
    /// 
    /// 
    public static MailAddressCollection GetEmails(this SystemEmailsElement value)
    {
        var emails = new MailAddressCollection();
        MailAddress eml = null;

        if (value.IsGroup())
        {
            switch (value.Source)
            {
                case SystemEmailsSource.RoleName:
                    if (value.RoleName != null)
                    {
                        foreach (UsersNames user in AppPublic.GetUsersByRole(value.RoleName))
                        {
                            eml = AppPublic.GetEmailByUserID(user.UserId);
                            if (eml != null)
                                emails.Add(eml);
                        }
                    }
                    break;

                default: //Group
                    foreach (var el in value.Emails)
                    {
                        foreach (MailAddress e in el.GetEmails())
                            emails.Add(e);
                    }
                    break;
            }
        }
        else
        {
            emails.Add(value.GetEmail());
        }

        if (emails.Count == 0)
        {
            eml = value.CreateEmailFromDefaults();
            if (eml != null)
                emails.Add(eml);
        }
        return emails;
    }

    /// 
    /// Gets the email result of this section or the first item in a group as a MailAddress object.
    /// Returns null if not able to create the MailAddress.
    /// 
    /// 
    public static MailAddress GetEmail(this SystemEmailsElement value)
    {
        if (value.IsGroup())
        {
            return value.GetEmails().FirstOrDefault();
        }
        else
        {
            MailAddress eml = null;

            if (value.Source == SystemEmailsSource.UserName)
            {
                if (value.UserName != null)
                    eml = AppPublic.GetEmailByUserName(value.UserName);
            }

            if (eml == null)
                eml = CreateEmailFromDefaults(value);

            return eml;
        }
    }

    /// 
    /// Creates a mail address object using the default attribute values from the SystemEmailElement.
    /// 
    /// 
    /// 
    private static MailAddress CreateEmailFromDefaults(this SystemEmailsElement value)
    {
        MailAddress eml = null;

        //DefaultEmailName takes precedence.
        if (value.DefaultEmailName != null)
        {
            var el = SystemEmailsConfiguration.GetConfig().Emails[value.DefaultEmailName];
            if (el != null)
                eml = el.GetEmail();
        }

        //Fall back to DefaultAddress.
        if (eml == null && value.DefaultAddress != null)
        {
            if (value.DefaultName == null)
                eml = new MailAddress(value.DefaultAddress);
            else
                eml = new MailAddress(value.DefaultAddress, value.DefaultName);
        }

        return eml;
    }
}

In an ideal world, the nodes would be renamed to nodes, and this code would be recursive and allow any (theoretical) number of node depths.

But if I could just get the first level working that would great. I've been spinning my wheels on this for hours trying to find the right combination of attributes, signatures, XML, etc.

Thanks!!

Evk · Accepted Answer

To fix your immediate error, you just need to add wrapping tag to your elements. That is because your SystemEmailsElement contains Emails property which is collection with root tag defined as "email" (via [ConfigurationProperty("email")]). Like this:

Now, to make it work like in ideal world, you can utilize IsDefaultCollection property of ConfigurationProperty attribute like this:

[ConfigurationProperty("", IsDefaultCollection = true)]
[ConfigurationCollection(typeof (SystemEmailsElementCollection),
    AddItemName = "email")]
public SystemEmailsElementCollection Emails
{
    get { return base[""] as SystemEmailsElementCollection; }
}

This will allow you to create recursive email nodes the way you would expect to:

Use ConfigurationSection / ConfigurationElementCollection to create a nested collection of items from web.config

Answers (1)

Related Questions