I have a windows application. I am writing all user specific settings into user.config.
Now in a new scenario, whatever changes one user does it should reflect to all the users.
For that purpose I thought of writing the settings into app.config through
Properties.Settings.Default.p1 = value;
Properties.Settings.Default.Save();
And every user read the updated default value after
Reset();
But what ever I do…it still writes to user.config not to app.config
From my experience, the Settings class cannot be used to modify default setting values for all users. In this situation, I modify the app.config directly using the classes in the System.Xml namespace. It is not ideal, but I have not found any other way to do it.
There are a couple things to keep in mind when modifying your app.config file:
If your program is installed in the Program Files folder, you may need to run your application as an administrator in order to save changes to the file. It will depend on how your security is configured.
If you change the namespace of your Settings class, it will change the structure of your app.config file, so you would need to update your code to account for the new XML structure.
See this MSDN article for more information about application and user scoped settings:
http://msdn.microsoft.com/en-us/library/8eyb2ct1%28v=vs.110%29.aspx
Related
I have the settings file in C# where I store the configuration parameters. So, I build the solution and install it in the system. The application creates an XML file user.config consisting of all the configuration parameters in :
%userprofile%\appdata\local or %userprofile%\Local Settings\
I made changes to the configuration through the application and save it by issuing the command
Properties.Settings.Default.Save();
When I restart the application, the configuration consists of the default values and not the updated values.
Any idea if I am missing something here.
%userprofile%\appdata\local or %userprofile%\Local Settings\
This is what is fundamentally wrong about the question, this is not where the user.config file is stored. The LocalFileSettingsProvider class (the default settings provider class) stores the user.config file in a directory with an unspeakable name, like C:\Users\username\AppData\Local\WindowsFormsApplication1\WindowsFormsApplication1._Url_twchbbo4atpsvjpauzkgkvesu5bh2aul\1.0.0.0
The twchbbo4atpsvjpauzkgkvesu5bh2aul part of the name is produced by a hashing function that combines the program install location, program name, [AssemblyCompany] and [AssemblyProduct] to ensure that the directory is unique and will not clash with the user.config of another program. And appending the [AssemblyVersion] so that different versions of the program won't clash.
You'll need to diagnose this problem by first finding the right user.config file back. Start from the %appdata%\Local or %appdata%\Roaming directory. Ensure that the Save() method actually saves, it won't if no setting was assigned a different value. Use SysInternals' ProcMon utility to double-check all assumptions, you'll see your program accessing the file in the trace.
What is the Scope of your settings? You cannot change Application Scoped settings like that from code.
Take a look at the settings designer.
You can read more about settings scope here.
I am working on a software and want to create a configuration file for my application to store configurations that will be used at runtime. I have seen some software use a config.xml file to achieve this. The configuration file I want to use will have:
Cache folder location
Color scheme
Option to toggle caching
How to go about this? I am working with WPF.
In Visual Studio, add an "app.config" to your project. When you build your application, this will create an AppName.exe.config file, where AppName is the name of your executable. This is an XML config file that can contain your settings.
If theses options are user-specific, don't use app.config - that's for global application settings and you will clobber other users' settings. I'm bringing this point up because you mentioned caching options in your question, and in some applications, the choice to cache or not to cache is at the user level.
Instead, I would recommend that you create a domain object to store the configuration settings to, and serialize the object to a local folder in the current user's isolated storage folder.
When the application starts up, just look into the current user's isolated storage folder, confirm the serialized file exists, and deserialize back to the domain object.
as you are in WPF world, you also can use App.XAML for defining and using color schemes
Use standard .NET settings framework.
More details here: How is the logic behind storing program setting in text file like 'config.cfg'?
Also this will help http://msdn.microsoft.com/en-us/library/aa730869%28v=vs.80%29.aspx.
Although this article is a little old, not much changed since then in this realm.
I'm building a simple winforms application which is using built-in settings for saving program options. All of the settings are per-user.
As I can see from the generated cs file the default settings are embedded in the source code but the application still reads the appname.exe.config file when launched. If I delete the file the application seems to be working fine but I want to make sure that it will not break anything.
So is the file required if I am only using per-user settings?
You should be using user settings instead of a configuration file. Refer to this article for more information, including how to read/write user settings.
The settings designer embeds the default value in a [DefaultSettingValue] attribute. The following section in the Remarks section of the attribute is relevant:
Different settings providers may have
different requirements or limitations
on the use of the
DefaultSettingValueAttribute. For
example, the LocalFileSettingsProvider
does not require this attribute, and
will override any value provided by
this attribute if there are any
values—default or user-modified—
already present in the data store.
LocalFileSettingsProvider is the default provider. So, it's there but it doesn't get used.
If you are using the Application Settings and you want persistence of the settings then yes this is where the options are saved. If you delete the file it will simply recreate it if the user changes a setting and you are setting the setting.
I need to give the user the ability to change application settings, in this case the location for the application database. I noticed that Application Settings are read only at run time, but this needs to be application-wide, not user-specific. How do I persist an application-wide connection string in windows.forms that is changeable at runtime?
You can use
ConfigurationManager.AppSettings.Set()
Also
ConnectionStringSettings.ConnectionString Property
Can be set too.
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
config.AppSettings.Settings.Add("test","tada");
config.Save(ConfigurationSaveMode.Minimal, true);
There isnt a direct way in the framework using the newer Settings classes - you can save user-level settings with the Settings support, but not application/machine level. Easiest way is to XmlSerialize a class and store it in a directory that is shared between all users with write acccess when they are running un-elevated such as the Public Documents folder (the program directory shouldnt be written to), e.g.. Environment.SpecialFolder.CommonApplicationData
EDIT: Yes, the old appSettings mechanism has a way of writing, but that's bad news - the newer Settings stuff omits this facility as it is bad news for lots of reasons to try to write to config files in Program Files
I know it is a good idea to store configuration data in app.config (e.g. database connection strings) instead of hardcoing it, even if I am writing an application just for myself. But is there a way to update the configuration data stored in app.config from the program that is using it?
If you use the Settings for the project, you can mark each setting as either application or user.
If they're set as user, they will be stored per-user and when you call the Save method it will be updated in the config for that user.
Code project has a really detailed article on saving all types of settings.
app.config isn't what you want to use for user-tweakable data, as it'll be stored somewhere in Program Files (which the user shouldn't have write permissions to). Instead, settings marked with a UserScopedSettingAttribute will end up in a user-scoped .config file somewhere in %LocalAppData%.
I found the best way to learn this stuff was to mess with the Visual Studio "Settings" tab (on your project's property pages), then look at the code that it generates and look in %LocalAppData% to see the file that it generates.