Settings Upgrade Does Nothing - c#

I have a C# application that uses several user settings to store its data. When I increase the version number of my application, those settings are lost and reset to their default values.
That's why I implemented the following code
if (Settings.Default.UpgradeRequired)
{
Settings.Default.Upgrade();
Settings.Default.UpgradeRequired = false;
Settings.Default.Save();
}
as suggested here.
The problem is: the call to Upgrade() does nothing. It does not throw an exception, but it does not load any of the old settings either. Every setting still has its default value afterwards.
Also my new application version stores its settings in a new folder, right next to the old settings' folder.
Am I holding it wrong? ;-)
PS: I checked that an old set of settings is stored on the disk with reasonable values. So there should be definately something to work with for Upgrade().

Seems I found the solution. Since my assembly was not strong named/signed, a new hash was generated every time I updated my application. Thus old settings were not found and the upgrade did not work.
To fix this I signed my assembly using a .snk file. This way the hash now stays fixed, and the upgrade works.

Related

Application settings cannot be upgraded

My C# application uses the default C# settings mechanism. The problem here is, that everytime I change my application's version number, all settings are gone and reset to their defaults.
Thus I implemented the upgrade mechanism described here.
Problem 1:
The weird thing is, that this seems to have no effect. After the upgrade code is executed, all settings still have their default values and none of the old values have been loaded.
Does the upgrade mechanism not work?
Problem 2:
Also after saving the settings, a new settings folder is created in AppData/Local (the name differs in the URI part). So after a couple of versions there are dozens of these folders lurking around, which does not feel right.
Is it normal behavior that an application creates new settings folders for each version?

Force all user settings to save

I have a C# program with various setting stored in the program project settings. As it is a command line program, these settings will be changed by the user in the user.config file. I can't work out how to force it to save all the default values.
Calling Properties.Settings.Default.Save(); only seems to work when I update a property in the program, which defeats the point of a persistent settings file.
If I run
Properties.Settings.Default.SomeSetting = "Help";
Properties.Settings.Default.Save();
In the config file I will see something like
< setting name="SomeSetting" serializeAs="String">
<value>Help</value>
< /setting>
What I want to happens is if the config file doesn't exist, create it and store all the settings. Then the user can change them if needed.
The way I managed to solve it was by modifying some existing code I had in a different project to handle version upgrades.
When the program runs:
if (PropertiesSettings.Default.UpgradeRequired)
{
Properties.Settings.Default.Upgrade();
Properties.Settings.Default.UpgradeRequired = false;
Properties.Settings.Default.Save();
reloadSettings();
}
// Assign settings to themselves and save
// This keeps settings the same as the defaults even when upgrading but ensures all settings appear in the config file
private void reloadSettings()
{
Properties.Settings.Default.Setting1 = Properties.Settings.Default.Setting1;
Properties.Settings.Default.Setting2 = Properties.Settings.Default.Setting2;
//etc
Properties.Settings.Default.Save();
}
The UpgradeRequired setting should be set to True by default, so a new version with no config will be forced to run the first if statement. The .NET Properties.Settings.Default.Upgrade(); should then take care of finding old config files and loading the old settings.
Settings are saved somewhere in user AppData folder specifically for a given process. For example, when the application is run under the debugger, you get different settings than when running stand-alone.
I would guess that there is no easy way to share settings across application using those properties settings. That code is quite old (.NET 2.0 or even before) so I think it is not designed to be easily customizable as it is often the case with more recent code.
I think that settings are good for things that are specific to a given application and if data need to be shared across application, then you should manage your own files.
Usually, one would use either XML or JSON based file and the data would be stored (by default) either under a subdirectory of My Documents if the data is intended to be visible to users or under a subdirectory of user application data directory if a regular user should not see those files.

C# application version management

I have a C# app with its corresponding setup program. It reads startup data from the registry and stores information under the "Environment.SpecialFolder.ApplicationData"\myapp folder.
My question is: If I make various changes to the code that include new registry keys, where should I reflect this in the new version so when re-running the setup it:
Keeps current registry keys/valuesAdds new Key/value to the registryLeaves "Application Data" untouched
The candidates are:
Assembly InfoFile Version
If there are others please let me know.
Thanks
I think your application should be able to create the regestry keys. You don't know if the user removes them manually to reset the settings to default. The Setup should only install and register components. (But the Uninstaller should ask the User if he want to remove the settings, or keep them.)
Solution A)
To avoid version-conflicts you can remember a extra version number for configuration. As an Example: Program Version 1.0 and 2.0 are using the configuration-set 1 while Program Version 3.0 uses a configuration-set 2, because there are obsolete/new settings. Just create a sub-key in your registry tree for every configuration-set.
"Application Data" can also include a subfolder with seperated configuration sets.
The major advantage is, that the user can downgrade without problems.
New versions can import old values from older configuration as default values.
Solution B)
Never delete (or change the type or range) settings. Just add new keys. Old program versions don't know them so they just ignoring it. This is very simple because there are no different configuration versions. But if your saving a lot of settings it can become complicated, because you cannot change the type of a setting. As an example you have to create a new key to change a setting from saving an integer to a long integer, because old versions don't understand long integers and will crash.

Property settings save is not working properly

I have a windows app that takes advantage of the Settings. I have a few user settings that the user can set manually, they are set as User scope. The save method works fine, however if the application is closed and then reopened, the values are set back to the defaults.
here is one example of my code to save:
Properties.Settings.Default["LocalDefaultPrinter"] = Default_Printer;
Properties.Settings.Default.Save();
what could be the problem?
I'm not sure if this is the problem, but I'm used to doing it using the designer generated properties:
Properties.Settings.Default.LocalDefaultPrinter = Default_Printer;
Properties.Settings.Default.Save();
EDIT: Well, that's not the problem - I was able to save fine using your approach provided the setting was "User" scoped. However, if you scope this as 'Application', you won't be able to save the value because that gets stored in your application.config file (application properties don't get saved back to that file on .Save).
When you alter user settings programmatically, you aren't altering the application config file. You are altering a copy of those settings in the user's profile that get merged with the application config at runtime.
Have you checked the user's profile folder for your altered settings? Are they there? If so, your code is functioning properly.
Thanks.
-Jason
In addition to these possibilities, understand that user settings are scoped to the version number of the executable. So, if you automatically increment your build or change your build number during debugging, you will lose any settings already updated by a prior version of the application.
For anyone having problems in WPF.
Call the Settings.Default.Upgrade() to retrieve the non-default values when you want to use the settings you saved.
Nevermind everyone. I forgot I had a method in the code that checked if the user set printer was the same as the system set printer and if not then change it to the system printer. Took that method out and all is well.
Application scoped settings are read only whereas user scoped settings are read/write. Calling Save() will persist the user scoped settings between application sessions. If LocalDefaultPrinter is application scoped this will not persist between sessions.
This post provides information on how to make use of the settings in its entirety.
I just experienced a similar problem with one specific key in user settings.
To solve it, I tried deleting the key and adding it back. Final solution, I added a new key with a new name it worked. Dumb solution but it worked.

How to keep user settings on uninstall

I'm using .NET user settings feature and I'm facing a problem.
When the application is uninstalled, then installed back, the user settings are lost.
I understand it's by design, and I want to be able to give the choice to the user in the installer.
Could you please give me some pointers to articles or documentation that will helps me?
Thanks a lot
.NET User Settings are not removed on uninstall. In fact the settings of all previous versions of the software are preserved in Local Settings directory.
When the new version is installed, a new version of the settings is created and default settings are used.
To ensure your application will merge new settings with previous configuration, you have to call Settings.Default.Upgrade() method.
So the solution is to manually remove settings on uninstall if we don't want to preserve them. Since what I needed was preserving previous settings, all I do now is creating a new setting called UpgradeRequired with true has the default value, then add this code at application startup:
if (Properties.Settings.Default.UpdateRequired)
{
Properties.Settings.Default.Upgrade();
Properties.Settings.Default.UpdateRequired = false;
}
You could possibly write the settings you wish to save out to the registry or write them as an XML file to a location that won't be impacted by the uninstall.
If you want to keep using User Settings i would suggest writing a custom installer class, and implement the onUninstalling method, to go find the file and copy it to another location known to the onInstall method of your custom installer. So that the next time the installer runs it could find the file.
I don't think you want to actually persist data on the users machine after an uninstall. Leaving files around is an evil practice, a big no-no. You should expose a feature in the application itself to either export those settings to a location of their choice and to then import it again after re-installing the app or to synchronize those settings onto a server so they're automatically available upon re-install, etc. On an uninstall you should leave no trace behind.

Categories

Resources