/// <summary>
/// Initializes properties based on the specified
/// property file locations.
/// </summary>
private void InitVariables()
{
variables = new NameValueCollection();
foreach (string sectionName in sectionNames)
{
object section = ConfigurationUtils.GetSection(sectionName);
if (section is NameValueCollection)
{
variables.Add((NameValueCollection)section);
}
#if NET_2_0
else if (section is System.Configuration.ClientSettingsSection)
{
System.Configuration.ClientSettingsSection clientSettingsSection = (System.Configuration.ClientSettingsSection)section;
foreach (SettingElement setting in clientSettingsSection.Settings)
{
variables.Add(setting.Name, setting.Value.ValueXml.InnerText);
}
}
#endif
else
{
throw new ArgumentException("Section [" + sectionName +
"] is not handled by the NameValueSectionHandler.");
}
}
}
public static void WriteSettingElement(Configuration config, ConfigurationSectionGroup sectionGroup, SettingsSerializeAs sas, string name, string value, string namespaceclass)
{
ConfigurationSection sec = sectionGroup.Sections.Get(namespaceclass);
System.Configuration.ClientSettingsSection clisec = sec as ClientSettingsSection;
if (clisec == null)
{
//创建节
clisec = new ClientSettingsSection();
sectionGroup.Sections.Add(namespaceclass, clisec);
}
SettingElement secEle = clisec.Settings.Get(name);
if (secEle == null)
{
secEle = new SettingElement(name, sas);
clisec.Settings.Add(secEle);
}
secEle.Value.ValueXml = new XmlDocument().CreateElement("value");
if (sas == SettingsSerializeAs.Xml)
{
XmlDocument xmdoc = new XmlDocument();
xmdoc.LoadXml(value);
secEle.Value.ValueXml.InnerXml = xmdoc.DocumentElement.OuterXml;
}
else
{
secEle.Value.ValueXml.InnerText = value;
}
}
private ClientSettingsSection DeclareUserSection(System.Configuration.Configuration config, string sectionName)
{
ConfigurationSectionGroup sectionGroup = config.GetSectionGroup("userSettings");
if (sectionGroup == null)
{
sectionGroup = new UserSettingsGroup();
config.SectionGroups.Add("userSettings", sectionGroup);
}
bool flag = false;
ConfigurationSection section = sectionGroup.Sections[sectionName];
if (section == null)
{
section = new ClientSettingsSection();
flag = true;
}
else if (section is DefaultSection)
{
section = this.ReadClientSettingsSection(section);
if (section != null)
{
sectionGroup.Sections.Remove(sectionName);
flag = true;
}
}
if (flag)
{
section.SectionInformation.AllowExeDefinition = ConfigurationAllowExeDefinition.MachineToLocalUser;
section.SectionInformation.RequirePermission = false;
sectionGroup.Sections.Add(sectionName, section);
}
return (section as ClientSettingsSection);
}
// Declares the section handler of a given section in its section group, if a declaration isn't already
// present.
private static void DeclareSection(Configuration config, string sectionName)
{
ConfigurationSectionGroup settingsGroup = config.GetSectionGroup(UserSettingsGroupName);
if (settingsGroup == null)
{
//Declare settings group
ConfigurationSectionGroup group = new UserSettingsGroup();
config.SectionGroups.Add(UserSettingsGroupName, group);
}
settingsGroup = config.GetSectionGroup(UserSettingsGroupName);
Debug.Assert(settingsGroup != null, "Failed to declare settings group");
if (settingsGroup != null)
{
ConfigurationSection section = settingsGroup.Sections[sectionName];
if (section == null)
{
section = new ClientSettingsSection();
section.SectionInformation.AllowExeDefinition = ConfigurationAllowExeDefinition.MachineToLocalUser;
section.SectionInformation.RequirePermission = false;
settingsGroup.Sections.Add(sectionName, section);
}
}
}
internal static IDictionary ReadSettingsFromFile(string configFileName, string sectionName, bool isUserScoped)
{
IDictionary dictionary = new Hashtable();
if (!isUserScoped || ConfigurationManagerInternalFactory.Instance.SupportsUserConfig)
{
string str = isUserScoped ? "userSettings/" : "applicationSettings/";
ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap();
ConfigurationUserLevel userLevel = isUserScoped ? ConfigurationUserLevel.PerUserRoaming : ConfigurationUserLevel.None;
if (isUserScoped)
{
fileMap.ExeConfigFilename = ConfigurationManagerInternalFactory.Instance.ApplicationConfigUri;
fileMap.RoamingUserConfigFilename = configFileName;
}
else
{
fileMap.ExeConfigFilename = configFileName;
}
ClientSettingsSection section = ConfigurationManager.OpenMappedExeConfiguration(fileMap, userLevel).GetSection(str + sectionName) as ClientSettingsSection;
if (section == null)
{
return(dictionary);
}
foreach (SettingElement element in section.Settings)
{
dictionary[element.Name] = new StoredSetting(element.SerializeAs, element.Value.ValueXml);
}
}
return(dictionary);
}
private void LoadProperties(ExeConfigurationFileMap exeMap, SettingsPropertyCollection collection, ConfigurationUserLevel level, string sectionGroupName, bool allowOverwrite, string groupName)
{
Configuration config = ConfigurationManager.OpenMappedExeConfiguration(exeMap, level);
ConfigurationSectionGroup sectionGroup = config.GetSectionGroup(sectionGroupName);
if (sectionGroup != null)
{
foreach (ConfigurationSection configSection in sectionGroup.Sections)
{
if (configSection.SectionInformation.Name != groupName)
{
continue;
}
ClientSettingsSection clientSection = configSection as ClientSettingsSection;
if (clientSection == null)
{
continue;
}
foreach (SettingElement element in clientSection.Settings)
{
LoadPropertyValue(collection, element, allowOverwrite);
}
// Only the first one seems to be processed by MS
break;
}
}
}
public void EditAfterAdd ()
{
Config cfg = ConfigurationManager.OpenExeConfiguration (ConfigurationUserLevel.None);
UserSettingsGroup u = new UserSettingsGroup ();
cfg.SectionGroups.Add ("userSettings", u);
ClientSettingsSection c = new ClientSettingsSection ();
u.Sections.Add ("mine", c);
}
protected virtual void Write <T>(SysConf.ClientSettingsSection section, string key, T value = default(T))
{
var settingElement = section.Settings.Get(key);
if (settingElement != null)
{
((SysConf.SettingValueElement)(settingElement.ElementInformation.Properties["value"].Value)).ValueXml.InnerText = value.ToString();
}
}
protected override void Write <T>(SysConf.ClientSettingsSection section, string key, T value = default(T))
{
if (section.SectionInformation.IsProtected)
{
section.SectionInformation.UnprotectSection();
}
_accessedSections.Add(section);
base.Write(section, key, value);
}
protected override T Read <T>(SysConf.ClientSettingsSection section, string key, T value = default(T))
{
if (section.SectionInformation.IsProtected)
{
section.SectionInformation.UnprotectSection();
}
_accessedSections.Add(section);
return(base.Read(section, key, value));
}
internal void RevertToParent(string sectionName, bool isRoaming)
{
if (!ConfigurationManagerInternalFactory.Instance.SupportsUserConfig)
{
throw new ConfigurationErrorsException(System.SR.GetString("UserSettingsNotSupported"));
}
System.Configuration.Configuration userConfig = this.GetUserConfig(isRoaming);
ClientSettingsSection section = this.GetConfigSection(userConfig, sectionName, false);
if (section != null)
{
section.SectionInformation.RevertToParent();
userConfig.Save();
}
}
private ClientSettingsSection GetConfigSection(System.Configuration.Configuration config, string sectionName, bool declare)
{
string str = "userSettings/" + sectionName;
ClientSettingsSection section = null;
if (config != null)
{
section = config.GetSection(str) as ClientSettingsSection;
if ((section == null) && declare)
{
this.DeclareSection(config, sectionName);
section = config.GetSection(str) as ClientSettingsSection;
}
}
return(section);
}
private void DeclareSection(System.Configuration.Configuration config, string sectionName)
{
if (config.GetSectionGroup("userSettings") == null)
{
ConfigurationSectionGroup group2 = new UserSettingsGroup();
config.SectionGroups.Add("userSettings", group2);
}
ConfigurationSectionGroup sectionGroup = config.GetSectionGroup("userSettings");
if ((sectionGroup != null) && (sectionGroup.Sections[sectionName] == null))
{
ConfigurationSection section = new ClientSettingsSection {
SectionInformation = { AllowExeDefinition = ConfigurationAllowExeDefinition.MachineToLocalUser, RequirePermission = false }
};
sectionGroup.Sections.Add(sectionName, section);
}
}
private void DeclareSection(System.Configuration.Configuration config, string sectionName)
{
if (config.GetSectionGroup("userSettings") == null)
{
ConfigurationSectionGroup group2 = new UserSettingsGroup();
config.SectionGroups.Add("userSettings", group2);
}
ConfigurationSectionGroup sectionGroup = config.GetSectionGroup("userSettings");
if ((sectionGroup != null) && (sectionGroup.Sections[sectionName] == null))
{
ConfigurationSection section = new ClientSettingsSection {
SectionInformation = { AllowExeDefinition = ConfigurationAllowExeDefinition.MachineToLocalUser, RequirePermission = false }
};
sectionGroup.Sections.Add(sectionName, section);
}
}
internal static void RevertToParent(string sectionName, bool isRoaming)
{
if (!ConfigurationManagerInternalFactory.Instance.SupportsUserConfig)
{
throw new ConfigurationErrorsException(SR.UserSettingsNotSupported);
}
Configuration config = GetUserConfig(isRoaming);
ClientSettingsSection section = GetConfigSection(config, sectionName, false);
// If the section is null, there is nothing to revert.
if (section != null)
{
section.SectionInformation.RevertToParent();
config.Save();
}
}
internal static void WriteSettings(string sectionName, bool isRoaming, IDictionary newSettings)
{
if (!ConfigurationManagerInternalFactory.Instance.SupportsUserConfig)
{
throw new ConfigurationErrorsException(SR.UserSettingsNotSupported);
}
Configuration config = GetUserConfig(isRoaming);
ClientSettingsSection section = GetConfigSection(config, sectionName, true);
if (section != null)
{
SettingElementCollection sec = section.Settings;
foreach (DictionaryEntry entry in newSettings)
{
SettingElement se = sec.Get((string)entry.Key);
if (se == null)
{
se = new SettingElement();
se.Name = (string)entry.Key;
sec.Add(se);
}
StoredSetting ss = (StoredSetting)entry.Value;
se.SerializeAs = ss.SerializeAs;
se.Value.ValueXml = ss.Value;
}
try
{
config.Save();
}
catch (ConfigurationErrorsException ex)
{
// We wrap this in an exception with our error message and throw again.
throw new ConfigurationErrorsException(SR.Format(SR.SettingsSaveFailed, ex.Message), ex);
}
}
else
{
throw new ConfigurationErrorsException(SR.SettingsSaveFailedNoSection);
}
}
private static ClientSettingsSection GetConfigSection(Configuration config, string sectionName, bool declare)
{
string fullSectionName = UserSettingsGroupPrefix + sectionName;
ClientSettingsSection section = null;
if (config != null)
{
section = config.GetSection(fullSectionName) as ClientSettingsSection;
if (section == null && declare)
{
// Looks like the section isn't declared - let's declare it and try again.
DeclareSection(config, sectionName);
section = config.GetSection(fullSectionName) as ClientSettingsSection;
}
}
return(section);
}
internal IDictionary ReadSettings(string sectionName, bool isUserScoped)
{
IDictionary dictionary = new Hashtable();
if (!isUserScoped || ConfigurationManagerInternalFactory.Instance.SupportsUserConfig)
{
string str = isUserScoped ? "userSettings/" : "applicationSettings/";
ConfigurationManager.RefreshSection(str + sectionName);
ClientSettingsSection section = ConfigurationManager.GetSection(str + sectionName) as ClientSettingsSection;
if (section == null)
{
return(dictionary);
}
foreach (SettingElement element in section.Settings)
{
dictionary[element.Name] = new StoredSetting(element.SerializeAs, element.Value.ValueXml);
}
}
return(dictionary);
}
private void LoadProperies(ExeConfigurationFileMap exeMap, SettingsPropertyCollection collection, ConfigurationUserLevel level, string sectionGroupName, bool allowOverwrite)
{
Configuration config = ConfigurationManager.OpenMappedExeConfiguration(exeMap, level);
ConfigurationSectionGroup sectionGroup = config.GetSectionGroup(sectionGroupName);
if (sectionGroup != null)
{
foreach (ConfigurationSection configSection in sectionGroup.Sections)
{
ClientSettingsSection clientSection = configSection as ClientSettingsSection;
if (clientSection != null)
{
foreach (SettingElement element in clientSection.Settings)
{
LoadPropertyValue(collection, element, allowOverwrite);
}
}
}
}
}
static Settings()
{
//load DB based settings...
using (Proc ControlCentral_s = new Proc("ControlCentral_s")) _DBSettings = ControlCentral_s.ExecuteNameValueCollection();
//load "app.config" file based settings...
//it should be noted that *saving* *directly* to the app.config file is a well known no-no... from a security standpoing which isn't really elaborated on much that i can find
//but that winds up meaning that the *Application* scoped settings accessible via {appname}.Properties.Settings.Default are code gen'd as read only properties.
//there's lots of folks whining about wanting to *write* to these properties for various reasons out in the forums...
//the main reason here is that we want the printer mappings to be settable by all users but at the application wide level not user based...
//i.e. we don't want every user to be required to select the same printers that everybody on this machine will be using
//i feel like i basically get the security implications that the administrator/installer must open read/write ACL on the Program Files\{app} folder and app.config file
//probalby because you can throw config info in those files which opens up even more access or something like that
//anyway, i'm still going for it until i read more about it... found the following code here: http://social.msdn.microsoft.com/Forums/en-US/csharpgeneral/thread/13428050-4fde-4c34-90f8-5255f4123a20/
ConfigurationSectionGroup applicationSectionGroup = appConfig.GetSectionGroup("applicationSettings");
applicationSettingsSection = applicationSectionGroup.Sections[ReflectionHelpers.CurrentAppName + ".Properties.Settings"] as ClientSettingsSection;
applicationSettingsSection.SectionInformation.ForceSave = true; //crucial, otherwise just doesn't save, even though documentation indicates that it supposedly means save even if there aren't changes
App = new SettingElementCollectionWrapper(applicationSettingsSection.Settings);
}
internal static IDictionary ReadSettingsFromFile(string configFileName, string sectionName, bool isUserScoped)
{
IDictionary settings = new Hashtable();
if (isUserScoped && !ConfigurationManagerInternalFactory.Instance.SupportsUserConfig)
{
return(settings);
}
string prefix = isUserScoped ? UserSettingsGroupPrefix : ApplicationSettingsGroupPrefix;
ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap();
// NOTE: When isUserScoped is true, we don't care if configFileName represents a roaming file or
// a local one. All we want is three levels of configuration. So, we use the PerUserRoaming level.
ConfigurationUserLevel userLevel = isUserScoped ? ConfigurationUserLevel.PerUserRoaming : ConfigurationUserLevel.None;
if (isUserScoped)
{
fileMap.ExeConfigFilename = ConfigurationManagerInternalFactory.Instance.ApplicationConfigUri;
fileMap.RoamingUserConfigFilename = configFileName;
}
else
{
fileMap.ExeConfigFilename = configFileName;
}
Configuration config = ConfigurationManager.OpenMappedExeConfiguration(fileMap, userLevel);
ClientSettingsSection section = config.GetSection(prefix + sectionName) as ClientSettingsSection;
if (section != null)
{
foreach (SettingElement setting in section.Settings)
{
settings[setting.Name] = new StoredSetting(setting.SerializeAs, setting.Value.ValueXml);
}
}
return(settings);
}
internal void WriteSettings(string sectionName, bool isRoaming, IDictionary newSettings)
{
if (!ConfigurationManagerInternalFactory.Instance.SupportsUserConfig)
{
throw new ConfigurationErrorsException(System.SR.GetString("UserSettingsNotSupported"));
}
System.Configuration.Configuration userConfig = this.GetUserConfig(isRoaming);
ClientSettingsSection section = this.GetConfigSection(userConfig, sectionName, true);
if (section != null)
{
SettingElementCollection settings = section.Settings;
foreach (DictionaryEntry entry in newSettings)
{
SettingElement element = settings.Get((string)entry.Key);
if (element == null)
{
element = new SettingElement {
Name = (string)entry.Key
};
settings.Add(element);
}
StoredSetting setting = (StoredSetting)entry.Value;
element.SerializeAs = setting.SerializeAs;
element.Value.ValueXml = setting.Value;
}
try
{
userConfig.Save();
return;
}
catch (ConfigurationErrorsException exception)
{
throw new ConfigurationErrorsException(System.SR.GetString("SettingsSaveFailed", new object[] { exception.Message }), exception);
}
}
throw new ConfigurationErrorsException(System.SR.GetString("SettingsSaveFailedNoSection"));
}
protected virtual T Read <T>(SysConf.ClientSettingsSection section, string key, T value = default(T))
{
var settingElement = section.Settings.Get(key);
if (settingElement != null)
{
try
{
var innerValue = ((SysConf.SettingValueElement)(settingElement.ElementInformation.Properties["value"].Value)).ValueXml.InnerText;
return((T)Convert.ChangeType(innerValue, typeof(T)));
}
catch (Exception)
{
if (value.Equals(default(T)))
{
throw;
}
}
}
return(value);
}
// Declares the section handler of a given section in its section group, if a declaration isn't already
// present.
private void DeclareSection(Configuration config, string sectionName) {
ConfigurationSectionGroup settingsGroup = config.GetSectionGroup(UserSettingsGroupName);
if (settingsGroup == null) {
//Declare settings group
ConfigurationSectionGroup group = new UserSettingsGroup();
config.SectionGroups.Add(UserSettingsGroupName, group);
}
settingsGroup = config.GetSectionGroup(UserSettingsGroupName);
Debug.Assert(settingsGroup != null, "Failed to declare settings group");
if (settingsGroup != null) {
ConfigurationSection section = settingsGroup.Sections[sectionName];
if (section == null) {
section = new ClientSettingsSection();
section.SectionInformation.AllowExeDefinition = ConfigurationAllowExeDefinition.MachineToLocalUser;
section.SectionInformation.RequirePermission = false;
settingsGroup.Sections.Add(sectionName, section);
}
}
}
internal static IDictionary ReadSettings(string sectionName, bool isUserScoped)
{
IDictionary settings = new Hashtable();
if (isUserScoped && !ConfigurationManagerInternalFactory.Instance.SupportsUserConfig)
{
return(settings);
}
string prefix = isUserScoped ? UserSettingsGroupPrefix : ApplicationSettingsGroupPrefix;
ConfigurationManager.RefreshSection(prefix + sectionName);
ClientSettingsSection section = ConfigurationManager.GetSection(prefix + sectionName) as ClientSettingsSection;
if (section != null)
{
foreach (SettingElement setting in section.Settings)
{
settings[setting.Name] = new StoredSetting(setting.SerializeAs, setting.Value.ValueXml);
}
}
return(settings);
}
private void SaveProperties(ExeConfigurationFileMap exeMap, SettingsPropertyValueCollection collection, ConfigurationUserLevel level, SettingsContext context, bool checkUserLevel)
{
Configuration config = ConfigurationManager.OpenMappedExeConfiguration(exeMap, level);
UserSettingsGroup userGroup = config.GetSectionGroup("userSettings") as UserSettingsGroup;
bool isRoaming = (level == ConfigurationUserLevel.PerUserRoaming);
if (userGroup == null)
{
userGroup = new UserSettingsGroup();
config.SectionGroups.Add("userSettings", userGroup);
}
ApplicationSettingsBase asb = context.CurrentSettings;
string class_name = NormalizeInvalidXmlChars((asb != null ? asb.GetType() : typeof(ApplicationSettingsBase)).FullName);
ClientSettingsSection userSection = null;
ConfigurationSection cnf = userGroup.Sections.Get(class_name);
userSection = cnf as ClientSettingsSection;
if (userSection == null)
{
userSection = new ClientSettingsSection();
userGroup.Sections.Add(class_name, userSection);
}
bool hasChanges = false;
if (userSection == null)
{
return;
}
foreach (SettingsPropertyValue value in collection)
{
if (checkUserLevel && value.Property.Attributes.Contains(typeof(SettingsManageabilityAttribute)) != isRoaming)
{
continue;
}
// The default impl does not save the ApplicationScopedSetting properties
if (value.Property.Attributes.Contains(typeof(ApplicationScopedSettingAttribute)))
{
continue;
}
hasChanges = true;
SettingElement element = userSection.Settings.Get(value.Name);
if (element == null)
{
element = new SettingElement(value.Name, value.Property.SerializeAs);
userSection.Settings.Add(element);
}
if (element.Value.ValueXml == null)
{
element.Value.ValueXml = new XmlDocument().CreateElement("value");
}
switch (value.Property.SerializeAs)
{
case SettingsSerializeAs.Xml:
element.Value.ValueXml.InnerXml = StripXmlHeader(value.SerializedValue as string);
break;
case SettingsSerializeAs.String:
element.Value.ValueXml.InnerText = value.SerializedValue as string;
break;
case SettingsSerializeAs.Binary:
element.Value.ValueXml.InnerText = value.SerializedValue != null?Convert.ToBase64String(value.SerializedValue as byte []) : string.Empty;
break;
default:
throw new NotImplementedException();
}
}
if (hasChanges)
{
config.Save(ConfigurationSaveMode.Minimal, true);
}
}
private ClientSettingsSection GetUserSettings(out Configuration config, bool tryAlternates)
{
config = null;
string[] files;
if (tryAlternates)
files = new string[] { this.FileName, this.BackupFileName };
else
files = new string[] { this.FileName };
for (int i = 0; i < files.Length; i++)
{
string p = files[i];
if(tryAlternates)
if (!System.IO.File.Exists(p)) continue;
try
{
ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap();
fileMap.ExeConfigFilename = p;
config = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
ConfigurationSection configSection = config.GetSection(USER_SETTINGS_SECTION_NAME);
ClientSettingsSection clientSettings = null;
if (configSection != null)
{
clientSettings = (ClientSettingsSection)configSection;
}
else
{
clientSettings = new ClientSettingsSection();
config.Sections.Add(USER_SETTINGS_SECTION_NAME, clientSettings);
}
// make a backup copy just in case
MakeBackup();
return clientSettings;
}
catch
{
// file is corrupt
if (!tryAlternates)
{
System.IO.File.Delete(p);
return GetUserSettings(out config, tryAlternates);
}
else
continue;
}
}
return null;
}
/// <summary>
/// Inits the specified configuration.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <param name="sectionName">The name of the section containing the settings.</param>
/// <exception cref="ArgumentNullException"><paramref name="configuration"/> is <c>null</c>.</exception>
/// <param name="sectionName">The name of the section containing the settings.</param>
internal Provider(System.Configuration.Configuration configuration, string sectionName)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
if (string.IsNullOrEmpty(sectionName))
{
throw new ArgumentNullException("sectionName");
}
_configuration = configuration;
_sectionName = sectionName;
var sectionGroup = configuration.GetSectionGroup("applicationSettings");
_applicationSection = sectionGroup == null ? null : sectionGroup.Sections[_sectionName] as ClientSettingsSection;
sectionGroup = configuration.GetSectionGroup("userSettings");
_userSection = sectionGroup == null ? null : sectionGroup.Sections[_sectionName] as ClientSettingsSection;
// The provider MUST have a name
Initialize(GetType().Name, null);
}
public void EditBeforeAdd ()
{
UserSettingsGroup u = new UserSettingsGroup ();
ClientSettingsSection c = new ClientSettingsSection ();
u.Sections.Add ("mine", c);
}
public static void Init()
{
SimpleDotNet.ReportUrl = @"http://code.google.com/p/simple-assembly-explorer/issues/list?can=2";
string configFile = Path.ChangeExtension(Application.ExecutablePath, ".exe.config");
if (!File.Exists(configFile))
{
throw new ApplicationException(String.Format("Application config file is missing: {0}.", Path.GetFileName(configFile)));
}
if (!File.Exists("user.config"))
{
using (StreamWriter sw = new StreamWriter("user.config"))
{
sw.WriteLine("<SimpleAssemblyExplorer.Properties.Settings>");
sw.WriteLine("</SimpleAssemblyExplorer.Properties.Settings>");
}
}
_config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
_css = (ClientSettingsSection)_config.SectionGroups["saeSettings"].Sections[0];
AddProperty(Consts.ShowAbout, true, typeof(bool));
AddProperty(Consts.CheckUpdatePeriod, 14, typeof(int));
AddProperty(Consts.CheckUpdateEnabled, true, typeof(bool));
AddProperty(Consts.CheckUpdateLastDate, new DateTime(2007, 1, 1), typeof(DateTime));
AddProperty(Consts.ClassEditorAutoSaveBookmarkEnabled, true, typeof(bool));
AddProperty(Consts.ClassEditorAutoOpenDroppedAssemblyEnabled, true, typeof(bool));
AddProperty(Consts.ClassEditorRichTextBoxFont, String.Empty, typeof(String));
AddProperty(Consts.ClassEditorBamlTranslator, 0, typeof(int));
AddProperty(Consts.LastPath, String.Empty, typeof(String));
AddProperty(Consts.LastSaveDir, String.Empty, typeof(String));
AddProperty(Consts.LastBinDir, String.Empty, typeof(String));
AddProperty(Consts.LastRegex, String.Empty, typeof(String));
AddProperty(Consts.MarkBlocks, true, typeof(bool));
AddProperty(Consts.SNOutputDir, String.Empty, typeof(String));
AddProperty(Consts.DeobfProfile, 0, typeof(int));
AddProperty(Consts.DeobfOutputDir, String.Empty, typeof(String));
AddProperty(Consts.DeobfFlowOptionBranchLoopCount, 2, typeof(int));
AddProperty(Consts.DeobfFlowOptionMaxMoveCount, 0, typeof(int));
AddProperty(Consts.DeobfFlowOptionMaxRefCount, 2, typeof(int));
AddProperty(Consts.DeobfFlowOptionBranchDirection, 0, typeof(int));
AddProperty(Consts.DasmOutputDir, String.Empty, typeof(String));
AddProperty(Consts.DasmAdditionalOptions, String.Empty, typeof(String));
AddProperty(Consts.AsmAdditionalOptions, String.Empty, typeof(String));
AddProperty(Consts.PEVerifyAdditionalOptions, String.Empty, typeof(String));
AddProperty(Consts.SNAdditionalOptions, String.Empty, typeof(String));
AddProperty(Consts.AsmOutputDir, String.Empty, typeof(String));
AddProperty(Consts.ClassEditorSaveAsDir, String.Empty, typeof(String));
AddProperty(Consts.ClassEditorLastSearch, String.Empty, typeof(String));
AddProperty(Consts.StrongKeyFile, String.Empty, typeof(String));
AddProperty(Consts.ProfilerAppFile, String.Empty, typeof(String));
AddProperty(Consts.ProfilerAppArgument, String.Empty, typeof(String));
AddProperty(Consts.ProfilerAppFilter, String.Empty, typeof(String));
AddProperty(Consts.ProfilerAppLogPath, String.Empty, typeof(String));
AddProperty(Consts.ProfilerAppTraceEvent, false, typeof(bool));
AddProperty(Consts.ProfilerAppTraceParameter, true, typeof(bool));
AddProperty(Consts.ProfilerAppIncludeSystem, false, typeof(bool));
AddProperty(Consts.ProfilerASPNetFilter, String.Empty, typeof(String));
AddProperty(Consts.ProfilerASPNetLogPath, String.Empty, typeof(String));
AddProperty(Consts.ProfilerASPNetTraceEvent, false, typeof(bool));
AddProperty(Consts.ProfilerASPNetTraceParameter, true, typeof(bool));
AddProperty(Consts.ProfilerASPNetIncludeSystem, false, typeof(bool));
AddProperty(Consts.RecentPluginList, 10, typeof(int));
AddProperty(Consts.RecentPlugins, null, typeof(StringCollection));
}
private void SaveProperties(ExeConfigurationFileMap exeMap, SettingsPropertyValueCollection collection, ConfigurationUserLevel level, SettingsContext context, bool checkUserLevel)
{
Configuration config = ConfigurationManager.OpenMappedExeConfiguration(exeMap, level);
UserSettingsGroup userGroup = config.GetSectionGroup("userSettings") as UserSettingsGroup;
bool isRoaming = (level == ConfigurationUserLevel.PerUserRoaming);
#if true // my reimplementation
if (userGroup == null)
{
userGroup = new UserSettingsGroup();
config.SectionGroups.Add("userSettings", userGroup);
ApplicationSettingsBase asb = context.CurrentSettings;
ClientSettingsSection cs = new ClientSettingsSection();
string class_name = NormalizeInvalidXmlChars((asb != null ? asb.GetType() : typeof(ApplicationSettingsBase)).FullName);
userGroup.Sections.Add(class_name, cs);
}
bool hasChanges = false;
foreach (ConfigurationSection section in userGroup.Sections)
{
ClientSettingsSection userSection = section as ClientSettingsSection;
if (userSection == null)
{
continue;
}
foreach (SettingsPropertyValue value in collection)
{
if (checkUserLevel && value.Property.Attributes.Contains(typeof(SettingsManageabilityAttribute)) != isRoaming)
{
continue;
}
// The default impl does not save the ApplicationScopedSetting properties
if (value.Property.Attributes.Contains(typeof(ApplicationScopedSettingAttribute)))
{
continue;
}
hasChanges = true;
SettingElement element = userSection.Settings.Get(value.Name);
if (element == null)
{
element = new SettingElement(value.Name, value.Property.SerializeAs);
userSection.Settings.Add(element);
}
if (element.Value.ValueXml == null)
{
element.Value.ValueXml = new XmlDocument().CreateElement("value");
}
switch (value.Property.SerializeAs)
{
case SettingsSerializeAs.Xml:
element.Value.ValueXml.InnerXml = (value.SerializedValue as string) ?? string.Empty;
break;
case SettingsSerializeAs.String:
element.Value.ValueXml.InnerText = value.SerializedValue as string;
break;
case SettingsSerializeAs.Binary:
element.Value.ValueXml.InnerText = value.SerializedValue != null?Convert.ToBase64String(value.SerializedValue as byte []) : string.Empty;
break;
default:
throw new NotImplementedException();
}
}
}
if (hasChanges)
{
config.Save(ConfigurationSaveMode.Minimal, true);
}
#else // original impl. - likely buggy to miss some properties to save
foreach (ConfigurationSection configSection in userGroup.Sections)
{
ClientSettingsSection userSection = configSection as ClientSettingsSection;
if (userSection != null)
{
/*
* userSection.Settings.Clear();
*
* foreach (SettingsPropertyValue propertyValue in collection)
* {
* if (propertyValue.IsDirty)
* {
* SettingElement element = new SettingElement(propertyValue.Name, SettingsSerializeAs.String);
* element.Value.ValueXml = new XmlDocument();
* element.Value.ValueXml.InnerXml = (string)propertyValue.SerializedValue;
* userSection.Settings.Add(element);
* }
* }
*/
foreach (SettingElement element in userSection.Settings)
{
if (collection [element.Name] != null)
{
if (collection [element.Name].Property.Attributes.Contains(typeof(SettingsManageabilityAttribute)) != isRoaming)
{
continue;
}
element.SerializeAs = SettingsSerializeAs.String;
element.Value.ValueXml.InnerXml = (string)collection [element.Name].SerializedValue; ///Value = XmlElement
}
}
}
}
config.Save(ConfigurationSaveMode.Minimal, true);
#endif
}
private static SettingElement GetSettingElement(ClientSettingsSection clientSection, PropertyInfo property, bool create)
{
SettingElement element = clientSection.Settings.Get(property.Name);
if (element == null && create)
{
element = new SettingElement(property.Name, SettingsClassMetaDataReader.GetSerializeAs(property));
clientSection.Settings.Add(element);
}
return element;
}
/// <summary>
///
/// </summary>
/// <param name="pConfiguration">Configuration del app.config</param>
/// <param name="pSectionName">Seccion</param>
/// <param name="pSectionGroupName">Grupo</param>
internal static void AddSection(Configuration pConfiguration, String pSectionName,String pSectionGroupName,String pSettingTemplateName)
{
ConfigurationSectionGroup wConfigurationSectionGroup =null;
SettingElement wSettingElement = null;
XmlDocument doc = new XmlDocument();
XmlNode xmlValue = doc.CreateNode(XmlNodeType.Element, "value", String.Empty);
ConfigurationSectionCollection wSections = null;
if (pSectionGroupName.Length == 0)
{
AddSectionFromAssembly(pConfiguration, pSectionName);
return;
}
else
{
wConfigurationSectionGroup = pConfiguration.GetSectionGroup(pSectionGroupName);
if (wConfigurationSectionGroup == null)
wConfigurationSectionGroup = AddSectionGroup(pConfiguration, pSectionGroupName);
wSections = wConfigurationSectionGroup.Sections;
}
if (wSections.Get(pSectionName) != null) return;
ClientSettingsSection wClientSettingsSection = new ClientSettingsSection();
wClientSettingsSection.SectionInformation.RequirePermission = false;
wClientSettingsSection.SectionInformation.ForceSave = true;
#region Settings
Dictionary<String, String> wSettings = TemplateProvider.GetSettingDic(pSettingTemplateName);
if (wSettings != null)
{
foreach (KeyValuePair<string, string> seting in wSettings)
{
wSettingElement = new SettingElement();
wSettingElement.Name = seting.Key;
xmlValue.InnerXml = seting.Value;
wSettingElement.Value.ValueXml = xmlValue.Clone();
wClientSettingsSection.Settings.Add(wSettingElement);
}
}
#endregion
wSections.Add(pSectionName, wClientSettingsSection);
}
/// <summary>
/// Gets the <see cref="SettingElementCollection"/> for the specified section name within
/// the specified configuration.
/// </summary>
/// <param name="config">The <see cref="Configuration"/> object.</param>
/// <param name="sectionName">The settings section name.</param>
/// <returns>
/// A <see cref="SettingElementCollection"/> for the section, or an empty section if not found.
/// </returns>
private static SettingElementCollection GetSettingElementCollection(Configuration config, string sectionName)
{
var userSettings = config.GetSectionGroup("userSettings");
if (userSettings == null)
{
userSettings = new UserSettingsGroup();
config.SectionGroups.Add("userSettings", userSettings);
}
var section = userSettings.Sections.Get(sectionName) as ClientSettingsSection;
if (section == null)
{
section = new ClientSettingsSection();
userSettings.Sections.Add(sectionName, section);
}
return section.Settings;
}
private static bool UpdateSection(ClientSettingsSection section, IEnumerable<PropertyInfo> properties, IDictionary<string, string> newValues)
{
bool modified = false;
foreach (PropertyInfo property in properties)
{
string newValue;
if (!newValues.TryGetValue(property.Name, out newValue))
continue;
SettingElement element = GetSettingElement(section, property, false);
if (newValue == null)
{
if (element != null)
{
section.Settings.Remove(element);
modified = true;
}
continue;
}
if (element != null)
{
string currentValue = GetElementValue(element);
if (Equals(newValue, currentValue))
continue;
}
else
{
element = GetSettingElement(section, property, true);
}
modified = true;
SetElementValue(element, newValue);
}
return modified;
}
private static bool UpdateSection(ClientSettingsSection clientSection, IEnumerable<PropertyInfo> properties, IDictionary<string, string> newValues)
{
bool modified = false;
foreach (PropertyInfo property in properties)
{
string newValue;
if (!newValues.TryGetValue(property.Name, out newValue))
continue;
SettingElement element = GetSettingElement(clientSection, property, false);
string currentValue = element == null ? null : GetElementValue(element);
string defaultValue = SettingsClassMetaDataReader.GetDefaultValue(property, false);
bool newValueIsDefault = newValue == null || Equals(newValue, defaultValue);
bool currentValueIsDefault = currentValue == null || Equals(currentValue, defaultValue);
if (currentValueIsDefault && newValueIsDefault || Equals(currentValue, newValue))
continue;
element = GetSettingElement(clientSection, property, true);
if (newValueIsDefault)
newValue = defaultValue; //store defaults because it's convenient for editing.
SetElementValue(element, newValue);
modified = true;
}
return modified;
}
//TODO (CR Sept 2010): instead of automatically storing all the defaults, should we
//just store what we're given and also delete stuff when we're given null? Then
//we could just return what's there in the "get" method rather than removing the defaults.
private static ClientSettingsSection CreateDefaultSection(IEnumerable<PropertyInfo> properties)
{
var section = new ClientSettingsSection();
section.SectionInformation.RequirePermission = false;
foreach (PropertyInfo property in properties)
{
var element = new SettingElement(property.Name, SettingsClassMetaDataReader.GetSerializeAs(property));
var valueElement = new SettingValueElement();
element.Value = valueElement;
string value = SettingsClassMetaDataReader.GetDefaultValue(property, false);
SetElementValue(element, value);
section.Settings.Add(element);
}
return section;
}
public void Add(string name, ClientSettingsSection section)
{
this.sectionGroup.Sections.Add(name, section);
}
private void DeserializeFromXmlElement(SettingsProperty property, SettingsPropertyValue spv, ClientSettingsSection clientSettings)
{
if (clientSettings != null)
{
SettingElement se = clientSettings.Settings.Get(spv.Name);
if (se != null)
{
string innerXml = se.Value.ValueXml.InnerXml;
if (se.SerializeAs == SettingsSerializeAs.String)
{
innerXml = this.Escaper.Unescape(innerXml);
}
spv.SerializedValue = innerXml;
innerXml = null;
}
else if (property.DefaultValue != null)
{
spv.SerializedValue = property.DefaultValue;
}
else
{
spv.PropertyValue = null;
}
}
}
private void SaveProperties (ExeConfigurationFileMap exeMap, SettingsPropertyValueCollection collection, ConfigurationUserLevel level, SettingsContext context, bool checkUserLevel)
{
Configuration config = ConfigurationManager.OpenMappedExeConfiguration (exeMap, level);
UserSettingsGroup userGroup = config.GetSectionGroup ("userSettings") as UserSettingsGroup;
bool isRoaming = (level == ConfigurationUserLevel.PerUserRoaming);
if (userGroup == null) {
userGroup = new UserSettingsGroup ();
config.SectionGroups.Add ("userSettings", userGroup);
}
ApplicationSettingsBase asb = context.CurrentSettings;
string class_name = NormalizeInvalidXmlChars ((asb != null ? asb.GetType () : typeof (ApplicationSettingsBase)).FullName);
ClientSettingsSection userSection = null;
ConfigurationSection cnf = userGroup.Sections.Get (class_name);
userSection = cnf as ClientSettingsSection;
if (userSection == null) {
userSection = new ClientSettingsSection ();
userGroup.Sections.Add (class_name, userSection);
}
bool hasChanges = false;
if (userSection == null)
return;
foreach (SettingsPropertyValue value in collection) {
if (checkUserLevel && value.Property.Attributes.Contains (typeof (SettingsManageabilityAttribute)) != isRoaming)
continue;
// The default impl does not save the ApplicationScopedSetting properties
if (value.Property.Attributes.Contains (typeof (ApplicationScopedSettingAttribute)))
continue;
hasChanges = true;
SettingElement element = userSection.Settings.Get (value.Name);
if (element == null) {
element = new SettingElement (value.Name, value.Property.SerializeAs);
userSection.Settings.Add (element);
}
if (element.Value.ValueXml == null)
element.Value.ValueXml = new XmlDocument ().CreateElement ("value");
switch (value.Property.SerializeAs) {
case SettingsSerializeAs.Xml:
element.Value.ValueXml.InnerXml = StripXmlHeader (value.SerializedValue as string);
break;
case SettingsSerializeAs.String:
element.Value.ValueXml.InnerText = value.SerializedValue as string;
break;
case SettingsSerializeAs.Binary:
element.Value.ValueXml.InnerText = value.SerializedValue != null ? Convert.ToBase64String (value.SerializedValue as byte []) : string.Empty;
break;
default:
throw new NotImplementedException ();
}
}
if (hasChanges)
config.Save (ConfigurationSaveMode.Minimal, true);
}
private ClientSettingsSection ReadClientSettingsSection(ConfigurationSection section)
{
ClientSettingsSection section2 = section as ClientSettingsSection;
if ((section2 == null) && (section is DefaultSection))
{
MethodInfo info = typeof(ClientSettingsSection).GetMethod("DeserializeSection", BindingFlags.NonPublic | BindingFlags.Instance, null, new System.Type[] { typeof(XmlReader) }, null);
if (info == null)
{
return section2;
}
section2 = new ClientSettingsSection();
using (XmlReader reader = XmlReader.Create(new StringReader(section.SectionInformation.GetRawXml())))
{
info.Invoke(section2, new object[] { reader });
}
}
return section2;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the section <paramref name="sectionName"/> in the section group "userSettings".
/// </summary>
/// ------------------------------------------------------------------------------------
private static ClientSettingsSection GetSection(Configuration config, string sectionName,
string sectionGroup = "userSettings")
{
var userSettingsGroup = config.GetSectionGroup(sectionGroup);
if (userSettingsGroup == null)
{
userSettingsGroup = new ConfigurationSectionGroup();
config.SectionGroups.Add(sectionGroup, userSettingsGroup);
}
var section = userSettingsGroup.Sections[sectionName] as ClientSettingsSection;
if (section == null)
{
section = new ClientSettingsSection();
userSettingsGroup.Sections.Add(sectionName, section);
}
return section;
}
private void SaveProperties (ExeConfigurationFileMap exeMap, SettingsPropertyValueCollection collection, ConfigurationUserLevel level, SettingsContext context, bool checkUserLevel)
{
Configuration config = ConfigurationManager.OpenMappedExeConfiguration (exeMap, level);
UserSettingsGroup userGroup = config.GetSectionGroup ("userSettings") as UserSettingsGroup;
bool isRoaming = (level == ConfigurationUserLevel.PerUserRoaming);
#if true // my reimplementation
if (userGroup == null) {
userGroup = new UserSettingsGroup ();
config.SectionGroups.Add ("userSettings", userGroup);
ApplicationSettingsBase asb = context.CurrentSettings;
ClientSettingsSection cs = new ClientSettingsSection ();
string class_name = NormalizeInvalidXmlChars ((asb != null ? asb.GetType () : typeof (ApplicationSettingsBase)).FullName);
userGroup.Sections.Add (class_name, cs);
}
bool hasChanges = false;
foreach (ConfigurationSection section in userGroup.Sections) {
ClientSettingsSection userSection = section as ClientSettingsSection;
if (userSection == null)
continue;
foreach (SettingsPropertyValue value in collection) {
if (checkUserLevel && value.Property.Attributes.Contains (typeof (SettingsManageabilityAttribute)) != isRoaming)
continue;
// The default impl does not save the ApplicationScopedSetting properties
if (value.Property.Attributes.Contains (typeof (ApplicationScopedSettingAttribute)))
continue;
hasChanges = true;
SettingElement element = userSection.Settings.Get (value.Name);
if (element == null) {
element = new SettingElement (value.Name, value.Property.SerializeAs);
userSection.Settings.Add (element);
}
if (element.Value.ValueXml == null)
element.Value.ValueXml = new XmlDocument ().CreateElement ("value");
switch (value.Property.SerializeAs) {
case SettingsSerializeAs.Xml:
element.Value.ValueXml.InnerXml = (value.SerializedValue as string) ?? string.Empty;
break;
case SettingsSerializeAs.String:
element.Value.ValueXml.InnerText = value.SerializedValue as string;
break;
case SettingsSerializeAs.Binary:
element.Value.ValueXml.InnerText = value.SerializedValue != null ? Convert.ToBase64String (value.SerializedValue as byte []) : string.Empty;
break;
default:
throw new NotImplementedException ();
}
}
}
if (hasChanges)
config.Save (ConfigurationSaveMode.Minimal, true);
#else // original impl. - likely buggy to miss some properties to save
foreach (ConfigurationSection configSection in userGroup.Sections)
{
ClientSettingsSection userSection = configSection as ClientSettingsSection;
if (userSection != null)
{
/*
userSection.Settings.Clear();
foreach (SettingsPropertyValue propertyValue in collection)
{
if (propertyValue.IsDirty)
{
SettingElement element = new SettingElement(propertyValue.Name, SettingsSerializeAs.String);
element.Value.ValueXml = new XmlDocument();
element.Value.ValueXml.InnerXml = (string)propertyValue.SerializedValue;
userSection.Settings.Add(element);
}
}
*/
foreach (SettingElement element in userSection.Settings)
{
if (collection [element.Name] != null) {
if (collection [element.Name].Property.Attributes.Contains (typeof (SettingsManageabilityAttribute)) != isRoaming)
continue;
element.SerializeAs = SettingsSerializeAs.String;
element.Value.ValueXml.InnerXml = (string) collection [element.Name].SerializedValue; ///Value = XmlElement
}
}
}
}
config.Save (ConfigurationSaveMode.Minimal, true);
#endif
}
} // SaveAs
// ----------------------------------------------------------------------
public void Import(UserConfig importUserConfig, bool overwriteSettings)
{
if (importUserConfig == null)
{
throw new ArgumentNullException("importUserConfig");
}
foreach (ConfigurationSectionGroup importSectionGroup in importUserConfig.configuration.SectionGroups)
{
UserSettingsGroup importUserSettingsGroup = importSectionGroup as UserSettingsGroup;
if (importUserSettingsGroup == null)
{
continue;
}
UserSettingsGroup userSettingsGroup = configuration.SectionGroups[importSectionGroup.Name] as UserSettingsGroup;
if (userSettingsGroup == null)
{
userSettingsGroup = new UserSettingsGroup();
configuration.SectionGroups.Add(importSectionGroup.Name, userSettingsGroup);
}
foreach (ConfigurationSection importSection in importSectionGroup.Sections)
{
ClientSettingsSection importClientSettingsSection = importSection as ClientSettingsSection;
if (importClientSettingsSection == null)
{
continue;
}
ClientSettingsSection clientSettingsSection = userSettingsGroup.Sections[importSection.SectionInformation.Name] as ClientSettingsSection;
if (clientSettingsSection == null)
{
clientSettingsSection = new ClientSettingsSection();
userSettingsGroup.Sections.Add(importSection.SectionInformation.Name, clientSettingsSection);
}
foreach (SettingElement importSettingElement in importClientSettingsSection.Settings)
{
bool newSetting = false;
SettingElement settingElement = clientSettingsSection.Settings.Get(importSettingElement.Name);
if (settingElement == null)
{
newSetting = true;
settingElement = new SettingElement();
settingElement.Name = importSettingElement.Name;
settingElement.SerializeAs = importSettingElement.SerializeAs;
clientSettingsSection.Settings.Add(settingElement);
}
if (!newSetting && !overwriteSettings)
{
continue;
}
SettingValueElement settingValueElement = new SettingValueElement();
settingValueElement.ValueXml = importSettingElement.Value.ValueXml;
settingElement.SerializeAs = importSettingElement.SerializeAs;
settingElement.Value = settingValueElement;
clientSettingsSection.Settings.Add(settingElement);
}
}
}
} // Import
/// <summary>
/// Save Last.fm.API library settings
/// </summary>
/// <returns>Indicate if settings was saved successful</returns>
public static bool Save()
{
if (!contextChanged)
{
return false;
}
switch (_configType)
{
case ConfigurationType.AppConfig:
return Instance.SaveConfig();
case ConfigurationType.FromFile:
return Instance.SaveFile(File.Exists(configFileName) ? configFileName : ConfigFileName);
default:
switch (Instance.AutoSaveSettings)
{
case AutoSaveSettingsMode.ToAppConfig:
{
string exeFile = Environment.GetCommandLineArgs()[0];
Configuration config = ConfigurationManager.OpenExeConfiguration(exeFile);
ConfigurationSection appSettings = config.Sections.Get(ConfigSectionName);
ClientSettingsSection newAppSettings = new ClientSettingsSection();
if (null == appSettings)
{
config.Sections.Add(ConfigSectionName, newAppSettings);
}
else
{
newAppSettings = (ClientSettingsSection)appSettings;
}
foreach (KeyValuePair<string, PropertyInfo> property in publicProperties)
{
SettingElement element = null;
Instance.ChangeValue(property.Value, property.Key, ref element);
newAppSettings.Settings.Add(element);
}
try
{
config.Save(ConfigurationSaveMode.Full);
}
catch (Exception)
{
return false;
}
_configType = ConfigurationType.AppConfig;
return true;
}
case AutoSaveSettingsMode.ToXmlFile:
bool bRes = Instance.SaveFile(ConfigFileName);
if (bRes)
{
_configType = ConfigurationType.FromFile;
}
return bRes;
default:
return false;
}
}
}
private bool Initialize()
{
IConfiguration configuration = GetConfiguration(SettingsLocation);
if (configuration == null) { return false; }
_configuration = configuration;
IConfigurationSectionGroup userGroup = this._configuration.GetSectionGroup(UserSettingsGroupName);
if (userGroup == null)
{
userGroup = configuration.AddSectionGroup(UserSettingsGroupName);
}
ClientSettingsSection clientSettings = userGroup.Get(SettingsSection) as ClientSettingsSection;
if (clientSettings == null)
{
clientSettings = new ClientSettingsSection();
clientSettings.SectionInformation.AllowExeDefinition = ConfigurationAllowExeDefinition.MachineToLocalUser;
clientSettings.SectionInformation.RequirePermission = false;
userGroup.Add(SettingsSection, clientSettings);
}
_clientSettings = clientSettings;
return true;
}
