AppSettings e ConnectionString sono entrambe proprietà direttamente disponibili su ConfigurationManager.
Tuttavia, ApplicationSettings e UserSettings, che corrispondono ai familiari Settings.settings è possibile modificare le impostazioni nel progettista VS, non sono così facili da raggiungere. AppSettings è NON uguale a applicationSettings che si trova in una sezione completamente diversa del file di configurazione in uso.
è necessario utilizzare il metodo mineraria sopra o una variante per arrivare al ApplicationSettings e UserSettings. Inoltre, le impostazioni dell'applicazione si aggiorneranno solo la prossima volta che avvierai l'applicazione, se sarai addirittura in grado di scrivere su di esse in fase di runtime.
Per esempio (cribbed da altrove - grazie):
public static string ReadSetting(string sectionGroupName, string sectionName, string settingName, Configuration config = null)
{
if (config == null)
config = SharedConfigSettings;
// Get sectionGroup
var sectionGroup =
config.GetSectionGroup(sectionGroupName);
// Get section
var section =
(ClientSettingsSection)sectionGroup.Sections.Get(sectionName);
// Get setting
var setting = section.Settings.Get(settingName);
// Read setting value
return setting.Value.ValueXml.InnerText;
}
e per un altro esempio (adaoted da molti esempi - grazie al mondo):
///<summary>
/// return the applicationSettings section
///</summary>
///<returns></returns>
public static ClientSettingsSection GetSettingsSection(ConfigurationSectionGroup group, string clientSectionName)
{
return (ClientSettingsSection)group.Sections[clientSectionName];
}
///<summary>
/// return the section settings collection
///</summary>
///<returns></returns>
public static System.Configuration.SettingElementCollection GetSettingsCollection(ClientSettingsSection section)
{
return section.Settings;
}
///<summary>
/// return the connectionStrings section collection
///</summary>
///<returns></returns>
public static System.Configuration.SettingElementCollection ConnectionStringsCollection()
{
return ((ClientSettingsSection)SharedConfigSettings.GetSection("connectionStrings")).Settings;
}
///<summary>
/// A collection of all the UserSettings in a SettingElementCollection
///</summary>
///<returns></returns>
public static SettingElementCollection UserSettings()
{
return
GetSettingsCollection(GetSettingsSection(GetSettingsSectionGroup(@"userSettings"),
@"MyAssembly.Properties.Settings"));
}
///<summary>
/// A collection of all the ApplicationSettings in a SettingElementCollection
///</summary>
///<returns></returns>
public static SettingElementCollection ApplicationSettings()
{
return
GetSettingsCollection(GetSettingsSection(GetSettingsSectionGroup(@"applicationSettings"),
@"MyAssembly.Properties.Settings"));
}
Poi, purtroppo devono ancora occuparsi degli oggetti SettingElement che si trovano nella raccolta delle impostazioni in queste sezioni. Ognuno deve deserializzare al tipo di proprietà a meno che non sia una stringa, ad es. un ApplicationSettings SettingElement (che non può essere aggiornata dinamicamente durante l'esecuzione):
(ginnico)
var y = GetSettingsSection(GetSettingsSectionGroup(@"applicationSettings"), @"MyAssembly.Properties.Settings");
var c = (y.Settings.Cast<SettingElement>().FirstOrDefault(s => s.Name == "WellKnownDirectories").Value).ValueXml
.InnerXml; // the setting as Xml
var xs = new XmlSerializer(typeof(string[]));
var strings = (string[])xs.Deserialize(new XmlTextReader(c, XmlNodeType.Element, null));
foreach (string s in strings)
{
Console.WriteLine(s);
}
Per una proprietà stringa è più facile (questo esempio è essenzialmente ridondante con il primo sopra):
var s = (y.Settings.Cast<SettingElement>().FirstOrDefault(s => s.Name == "MyUserSettingName").Value).ValueXml
.InnerText
Tutti questi esempi hanno giocato con le impostazioni dell'applicazione. Lo stesso approccio può funzionare con userSettings con l'aggiunta di probabilmente alcuni metodi di salvataggio e così via, e devi tenere traccia (più o meno) di quale dei molti molti file di configurazione sono effettivamente in riproduzione: main, roaming o locale .
Perché sto facendo questo? Poiché due applicazioni correlate e una libreria di classi comuni (o librerie) devono tutte utilizzare le stesse impostazioni di proprietà di una delle applicazioni in cui le impostazioni sono gestite visivamente. Qualcuno ha risolto questo in un modo migliore?
Grazie.
OK. Posso leggere l'array di stringhe in questo modo. Ma le stringhe provengono dal default compilato nell'assembly. Devo essere in grado di aggiungere, rimuovere e modificare stringhe in quella raccolta dopo che l'assembly è stato distribuito. Il .Properties.Settings.Default non rileva modifiche nel file .config. Ha avuto lo stesso problema con le stringhe di connessione fino a quando ho iniziato a passare attraverso il ConfigurationManager. –
Probabilmente è necessario accedere al metodo di ConfigurationManager: ConfigurationManager.GetSection ("applicationSettings"); che dovrebbe restituire l'oggetto per il quale si desidera analizzare – jkelley
ConfigurationManager.GetSection ("applicationSettings") restituisce null –