[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator","8.0.0.0")]
internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {

 [global::System.Configuration.UserScopedSettingAttribute()]
 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
 public global::System.Collections.ArrayList test {
  get { return ((global::System.Collections.ArrayList)(this["test"])); }
  set { this["test"] = value; }    
 }
}

    public sealed class Test
    {
        public int i = 3;
        public Test() { }
    }

    public sealed class Test
    {
        [NonSerialized]
        public int i = 1;
    }

[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator","8.0.0.0")]
internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {

 [global::System.Configuration.UserScopedSettingAttribute()]
 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
 public Test test {
  get { return ((Test)(this["test"])); }
  set { this["test"] = value; }    
 }
}

                    Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
                    _current = (Settings)config.GetSection(sectionName);

                Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
                config.Sections.Remove(sectionName);
                config.Sections.Add(sectionName, new Settings(_current)); // получить новый экземпляр, с помощью конструктора копии
                config.Save(ConfigurationSaveMode.Full);

                Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
O>>                config.Sections.Remove(sectionName);
O>>                config.Sections.Add(sectionName, new Settings(_current)); // получить новый экземпляр, с помощью конструктора копии
O>>                config.Save(ConfigurationSaveMode.Full);
O>>

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="TestSettingsClass" type="Test.Settings.TestSettingsClass, TestAssembly" restartOnExternalChanges="true" />
  </configSections>
  <TestSettingsClass UnknownCity="374" UnknownStreet="unk street" UnknownCountry="UA" UnknownRegion="81" UnknownZipCode="0001" WorldRegion="1">
    <Database Server="servername" File="d:\test.fdb" Dialect="1" User="sysdba" Password="masterkey" Charset="WIN1251" Pooling="False"/>
  </TestSettingsClass>
</configuration>

using System;
using System.Configuration;
using System.Reflection;
using System.IO;

namespace Test.Settings
{
    /// <summary>
    /// holds settings for TestSettingsClass client export
    /// </summary>
    public class TestSettingsClass : ConfigurationSection
    {
        private static TestSettingsClass _current = null;
        public const string sectionName = "TestSettingsClass";

        public static TestSettingsClass Current
        {
            get
            {
                if (_current == null)
                {
                    Configuration config = ConfigurationManager.OpenExeConfiguration(Assembly.GetExecutingAssembly().Location);
                    _current = (TestSettingsClass)config.GetSection(sectionName);

                    FileWatcher.StartWatching(ConfigFile_Changed);
                }
                return _current;
            }
        }

        private static void ConfigFile_Changed(object sender, FileSystemEventArgs e)
        {
            ConfigurationManager.RefreshSection(sectionName);
            Log.Info("{0} section has been reloaded", sectionName);
            _current = (TestSettingsClass)ConfigurationManager.GetSection(sectionName);
        }

        private const string DatabaseName = "Database";
        [ConfigurationProperty(DatabaseName)]
        public Database Database
        {
            get { return (Database)this[DatabaseName]; }
        }

        private const string UnknownCityName = "UnknownCity";
        [ConfigurationProperty(UnknownCityName)]
        public string UnknownCity
        {
            get { return (string) this[UnknownCityName]; }
        }

        private const string UnknownStreetName = "UnknownStreet";
        [ConfigurationProperty(UnknownStreetName)]
        public string UnknownStreet
        {
            get { return (string)this[UnknownStreetName]; }
        }

        private const string UnknownCountryName = "UnknownCountry";
        [ConfigurationProperty(UnknownCountryName)]
        public string UnknownCountry
        {
            get { return (string) this[UnknownCountryName]; }
        }

        private const string UnknownRegionName = "UnknownRegion";
        [ConfigurationProperty(UnknownRegionName)]
        public string UnknownRegion
        {
            get { return (string)this[UnknownRegionName]; }
        }

        private const string UnknownZipCodeName = "UnknownZipCode";
        [ConfigurationProperty(UnknownZipCodeName)]
        public string UnknownZipCode
        {
            get { return (string) this[UnknownZipCodeName]; }
        }

        private const string WorldRegionName = "WorldRegion";
        [ConfigurationProperty(WorldRegionName)]
        public string WorldRegion
        {
            get { return (string)this[WorldRegionName]; }
        }
    }

    public class Database : ConfigurationElement
    {
        public const string ServerName = "Server";
        [ConfigurationProperty(ServerName, DefaultValue = "server could not be read")]
        public string Server
        {
            get { return (string)this[ServerName]; }
            set { this[ServerName] = value; }
        }

        public const string DatabaseName = "File";
        [ConfigurationProperty(DatabaseName, DefaultValue = "database could not be read")]
        public string File
        {
            get { return (string)this[DatabaseName]; }
            set { this[DatabaseName] = value; }
        }

        public const string UserName = "User";
        [ConfigurationProperty(UserName, DefaultValue = "user could not be read")]
        public string User
        {
            get { return (string)this[UserName]; }
            set { this[UserName] = value; }
        }

        public const string PasswordName = "Password";
        [ConfigurationProperty(PasswordName, DefaultValue = "password could not be read")]
        public string Password
        {
            get { return (string)this[PasswordName]; }
            set { this[PasswordName] = value; }
        }

        public const string DialectName = "Dialect";
        [ConfigurationProperty(DialectName, DefaultValue = "1")]
        public string Dialect
        {
            get { return (string)this[DialectName]; }
            set { this[DialectName] = value; }
        }

        public const string RoleName = "Role";
        [ConfigurationProperty(RoleName, DefaultValue = "")]
        public string Role
        {
            get { return (string)this[RoleName]; }
            set { this[RoleName] = value; }
        }

        public const string CharsetName = "Charset";
        [ConfigurationProperty(CharsetName, DefaultValue = "")]
        public string Charset
        {
            get { return (string)this[CharsetName]; }
            set { this[CharsetName] = value; }
        }

        public const string PoolingName = "Pooling";
        [ConfigurationProperty(PoolingName, DefaultValue = true)]
        public bool Pooling
        {
            get { return (bool)this[PoolingName]; }
            set { this[PoolingName] = value; }
        }
    }
}

Console.WriteLine(TestSettingsClass.Current.UnknownCountry);
if(TestSettingsClass.Current.Database.Pooling)
    Console.WriteLine("pooling enabled");