Custom Configuration Section can only be saved/modified while running as administrator?

Question

I wrote a custom configuration section, collection, and element to add/modify to my app.config. All seems to be going well and it works perfectly running in Visual Studio. However, when I install the application and it comes time to save the new data to the custom config section, the following exception is thrown:

System.Configuration.ConfigurationErrorsException: Unable to save config to file '{path to config file}'

The interesting part is that if I run the application in administrator mode, everything works fine. Is there any reason it would only work as administrator?

EDIT:

I should note that I don't think its a permissons issue because a) we have other apps that modify the <applicationSettings> of their app.configs just fine there and b) log4net is able to write its log file just fine there.

Custom Config Element:

public class AuditorColorElement : ConfigurationElement
{
    public AuditorColorElement()
    {
    }

    public AuditorColorElement(Color color, string auditor)
    {
        Color = color;
        Auditor = auditor;
    }

    [ConfigurationProperty(nameof(Color), IsRequired = true, IsKey = true)]
    public Color Color
    {
        get { return (Color)base[nameof(Color)]; }
        set { this[nameof(Color)] = value; }
    }

    [ConfigurationProperty(nameof(Auditor), IsRequired = true)]
    public string Auditor
    {
        get { return (string)base[nameof(Auditor)]; }
        set { this[nameof(Auditor)] = value; }
    }
}

Custom Config Section:

[ConfigurationCollection(typeof(AuditorColorElement))]
public class AuditorColorElementCollection : ConfigurationElementCollection, IEnumerable<AuditorColorElement>
{
    internal const string PropertyName = "AuditorColors";

    public AuditorColorElementCollection() : base()
    {
    }

    public AuditorColorElementCollection(AuditorColorElementCollection collection)
    {
        foreach (AuditorColorElement element in collection)
        {
            Add(element);
        }
    }

    public override ConfigurationElementCollectionType CollectionType
    {
        get
        {
            return ConfigurationElementCollectionType.AddRemoveClearMapAlternate;
        }
    }

    protected override string ElementName
    {
        get
        {
            return PropertyName;
        }
    }

    public AuditorColorElement this[int idx]
    {
        get { return (AuditorColorElement)BaseGet(idx); }
    }

    protected override bool IsElementName(string elementName)
    {
        return elementName.Equals(PropertyName,
        StringComparison.InvariantCultureIgnoreCase);
    }

    public override bool IsReadOnly()
    {
        return false;
    }

    protected override ConfigurationElement CreateNewElement()
    {
        return new AuditorColorElement();
    }

    protected override object GetElementKey(ConfigurationElement element)
    {
        return ((AuditorColorElement)(element)).Color;
    }

    public void Add(AuditorColorElement element)
    {
        BaseAdd(element);
    }

    public void Clear()
    {
        BaseClear();
    }

    public void Remove(AuditorColorElement element)
    {
        BaseRemove(element.Color);
    }

    public void RemoveAt(int index)
    {
        BaseRemoveAt(index);
    }

    public void Remove(Color color)
    {
        BaseRemove(color);
    }

    public object GetKey(object key)
    {
        return BaseGet(key);
    }

    public bool ContainsKey(object key)
    {
        return GetKey(key) != null ? true : false;
    }

    public new IEnumerator<AuditorColorElement> GetEnumerator()
    {
        foreach (var key in this.BaseGetAllKeys())
        {
            yield return (AuditorColorElement)BaseGet(key);
        }
    }
}

Custom Config Section

public class AuditorColorSection : ConfigurationSection
{
    [ConfigurationProperty(nameof(AuditorColors), IsRequired = true, IsDefaultCollection = true)]
    [ConfigurationCollection(typeof(AuditorColorElementCollection),
        AddItemName = "add",
        ClearItemsName = "clear",
        RemoveItemName = "remove")]
    public AuditorColorElementCollection AuditorColors
    {
        get { return ((AuditorColorElementCollection)(base[nameof(AuditorColors)])); }
        set { base[nameof(AuditorColors)] = value; }
    }

    public AuditorColorSection()
    {
        AuditorColors = new AuditorColorElementCollection();
    }
}

Where are you writing to? Where physically? Does the user running your app have permission to write there? — mariocatch, May 06 '16 at 15:54
I guess this might help you [How to get admin privileges for editing app.config in C#?](http://stackoverflow.com/questions/3147171/how-to-get-admin-privileges-for-editing-app-config-in-c) — Raktim Biswas, May 06 '16 at 15:56
@mariocatch Writing to ProgramData, but other apps in our suite modify config files just fine that are also stored there. Is there a difference between the section being modified (which works for our other apps) vs a custom section in terms of permissions? Also, my app uses log4net which doesn't seem to have an issue writing the log to that location. — Hershizer33, May 06 '16 at 16:01
what doe syour app.config look like? Just the section declaration part — mariocatch, May 06 '16 at 16:04
@mariocatch Well its a custom section so it doesn't exist first run, but when its created successfully (Debug mode or run as Admin) it looks like this: `
` — Hershizer33, May 06 '16 at 16:07

score 2 · Accepted Answer · edited May 23 '17 at 12:31

2

I'm not a fan of using methods in the System.Configuration namespace to write to config files. Reading values using methods in the System.Configuration namespace is never a problem.

Just use LinqToXML instead, at least to check if that is the problem.

I'm guessing your app is installed in C:\Program Data so while it could be permissions related I suspect the root cause of the System.Configuration.ConfigurationErrorsException: Unable to save config to file is a lock on the file, use this code to check if that assumption is correct.

edited May 23 '17 at 12:31

Community

1
1

answered May 11 '16 at 12:51

Jeremy Thompson

61,933
36
195
321

So I wasn't using `System.Configuration` namespace to write the actual file (file was created by Add-->New Item in VS itself and set to copy to output), but it was just an empty config file with the standard tag of ``. As stated the error occurred when triying to open the file and save changes to it. What I did that ended up fixing the issue is creating the XML file in code with XML Writer and writing the top level `` tag with it. The remaining of the code was unchanged and yet this time it works. Does that point to your theory of it being locked? – Hershizer33 May 11 '16 at 15:11
1

All the attributes you're using are in the `System.Configuration` namespace, eg [ConfigurationProperty](https://msdn.microsoft.com/en-us/library/system.configuration.configurationproperty(v=vs.110).aspx). I've had heaps of problems with writing to config files using those types of methods . It was just a hunch/assumption/guess the root cause of why it fails is because the file is locked. If its not permissions related, and not a file not found then the next logical choice is that the file locked. The main point was using LinqToXML or XML Writer instead. I'm glad you got it working. – Jeremy Thompson May 11 '16 at 15:18
1

Thanks me too, was very confusing and I still don't see the difference between using `System.Configuration` to edit a file created compile time (didn't work) vs a file created at runtime (worked via XMLWriter), but suspect it has something to do with permissions but past that its just speculation. – Hershizer33 May 11 '16 at 15:23

Custom Configuration Section can only be saved/modified while running as administrator?

1 Answers1

Linked