How can I overwrite the app.config file form the App Data folder with the default one by code?
Not sure what you mean but you can use at the configurationSettings class to manage settings, you can also use a simple Data.XML namespace and change the XML in the config file and save it back but just beware that it is not the recommanded.
typically i have always created an config object that i read all the config file settings and use it as a singleton in my code. if you want you can add a save method to the class that saves back the config file if you want to persist the changes that your code makes to the config class.
You can use a settings file. The VS designer will generate a proxy class for you. For each entry you can specify in the properties window wether you want to "GenerateDefaultInCode" or not. This way, you can configure your settings in the app.config file under the "ApplicationsSettings" section and at the same time rely on default values (set via attributes in the proxy class) in the generated code.
See http://msdn.microsoft.com/en-us/library/aa730869(VS.80).aspx for how to add a .settings file to your project.
As pointed out here default values should be used with care because they can lead to error-prone behaviour when you deploy to a different environment.
Related
I'm trying to write a small game in VisualStudio, C# language to improve and practice. The thing I'm trying to do is to have a config file that the user can edit with the settings menu in the game. I know I could write a simple .ini file and parse that when the program starts, but is there a better and simpler way to do it?
Just serialize/deserialize the whole class representing your settings to/from a file, that's the easiest to implement. You can use e.g. Json.NET
File.WriteAllText(#"C:\config.json", JsonConvert.SerializeObject(settings));
var settings = JsonConvert.DeserializeObject<Settings>(File.ReadAllText(#"C:\config.json"));
1- Add an Application Configuration File to your project (right
click project > add item). This will be called app.config inside your project.
2- Add Parameter to the file by :
System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(Application.ExecutablePath);
config.AppSettings.Settings.Add("Yourkey","Value");
config.Save(ConfigurationSaveMode.Minimal);
3 - Retrieve Data:
Configuration config =
ConfigurationManager.OpenExeConfiguration(Application.ExecutablePath);
string Value = config.AppSettings.Settings["Yourkey"].Value
You can use a the integrated settings functionality in .NET Framework in the System.Configuration namespace.
To create a settings file, you need to add one in visual studio via the add element dialog. Select "Settings" an give it a name.
Add settings file to yout project
Then you need to add settings to the file. There is a nice gui editor when you doble click on the file in solution explorer:
Add settings to file
To access the values in code, you need get an instace of the settings object via the static propertie calles "Default" in you settings class:
Access settings value in code
Don´t forget to call MySettingsClass.Default.Save() to save changed values before you close your application.
There are much more features than read an save values withe this method. You can read more about it here and here.
Is there a built-in mechanism for serializing changes to your app.config file using built-in functions available in .NET?
For instance, if I have a custom property set in Executable.exe.config that changes during runtime, I would like .NET to update the Executable.exe.config accordingly.
I know I could do this by creating my own serialization mechanism, but would like to know if it's possible using functionality already available in .NET by default.
You can use the ConfigurationManager class.
There are a lot of sample on the link above or on this article that also provides a short sample.. You need to add a reference to System.Configuration, and basically, you access and save the file like this:
// Open App.Config of executable
System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
// Do stuff
// Save the configuration file.
config.Save(ConfigurationSaveMode.Modified);
In order to force your program to immediatly take the refreshed data, you need to refresh the section using the ConfigurationManager.RefreshSection method
// Force a reload of a changed section.
ConfigurationManager.RefreshSection("appSettings");
And an important note from this thread, for those that say that it doesn't work in debug mode:
If you are running the code from the debugger (within VS) than your
code is actually changing the YourAssemblyName.vshost.exe.Config If
you start YourAssemblyName .exe directly from the bin\debug folder it
will change YourAssemblyName.exe.Config
I need to store few config values which will be changed by the application administrator. I do not want to store them in web.config files, because whenever web.config file is edited the system will recompile the application.
DBA is not letting me to create a table to store it in database.
Can you suggest some way where I can store this editable values.
Thank you for the suggestion.
it is a ASP.NET application.
You could store them in your own config file. For example you could put this file inside the ~/App_Data folder and then read the config file when you need the values. As far as the format of this file is concerned you have many choices: plain Text, XML, JSON, whatever you like.
As an alternative you could write your own ConfigSection and set restartOnExternalChanges="false".
Then, when reading the section with ConfigurationManager.GetSection("yourSection") the settings will be auto-refreshed without an application restart.
If you still wish to keep web.config untouched, you can use configSource property to set external file where your settings will be kept.
To design a new section you can use this tool: http://csd.codeplex.com/
I'm wondering if there is a way to create settings in a config file for individual programmers. The situation I'm encountering is that there are some programmers who want settings turned on and several that want them turned off. Our config files are in SVN source control, so using a shared config file means we are always overwriting each others settings. We are doing this for an ASP.NET web application project. My initial thoughts would be to create a config file outside of source control, but how do I make it so that each programmer has his own copy?
Here is some further clarification. We have a link in the main web.config file that points to an environment-based file (e.g. file used for dev, staging and live).
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<appSettings configSource="EnvironmentConfigs\appSettings.config" />
...
</configuration>
Inside the appSettings.config file, we have settings for dev, staging and live. What I'd like to do is create another config file called user.config and have the individual programmer settings staored there (not in source control of course). What do I need to do in order to have visual studio read from this new file?
The settings file does not need to be versioned in SVN, or each developer can select their settings file to not be overwritten or committed. See the SVN settings file, it could even be added as a global ignore.
Each developer can set up their own build congifuration in Visual Studio. This build configuration should be linked to a build script, which replaces sections of the Web.Config/App.Config/*.Config files specifically as the developer wants.
This way, when they want to make changes to the config files to suit themselves, they should change the replacements in the build script rather than changing the config file directly.
This article covers some of the points i've mentioned: http://www.diaryofaninja.com/blog/2010/05/09/automated-site-deployments-with-teamcity-deployment-projects-amp-svn
Remove the config file from source control and set the svn:ignore property on it. Then it won't be committed. Then, also create another file, like, Production.web.config, that has the production values in it, so you still keep those around too.
That's what I do!
Don't commit config file changes unless they are new settings that to be sent to everyone.
Otherwise, checkout, edit, and leave it checked out. You'll know if someone else has added/modified the file when you get latest version. At which time you merge your settings with their changes, but leave it checked out on your machine.
We do not store application configuration files in source control. Instead, in source control, we store a configuration file template, usually named something like web.config.template. Each developer has their own 'values' file, usually named web.config.values-bem for instance. Each developer also sets up a post-commit hook which takes the template file, and processes it, replacing 'variables' with their values from the specified values file.
For instance, my config values file has the following definition in it:
DB_SERVER=.\SQLEXPRESS
In the web.config.template file, this exists:
connectionString="server=#DB_SERVER#[DEV1];Persist Security Info=True;Password=#DB_PW#;User ID=#DB_USER#;database=#DB_NAME#;Enlist=false;Max Pool Size=100" />
So when the process runs (a python script), it replaces all instances of #DB_SERVER# with the setting I have in my values file. The template script allows for default values to be specified right in the template as well, so you can make changes to the template file and not break other developers' environments (usually). (The default values are next to the variable, in square brackets.)
This solution allows each developer to have their own settings, but still have a web.config.template file that's versioned, and each developer avoids 'inflicting' configuration changes on other developers.
This works well for us. If you want to use the same scheme, you can check out the code for it on my github: https://github.com/bmontgomery/FileReplace. I can help you with the hook scripts as well if you're interested in that.
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.