Settings Changes Not Being Saved

RogerSchlueter-7899 1,781 Reputation points
2026-04-14T12:10:49.1933333+00:00

My app has several settings that the user can change. The code that saves the changes is:

My.Settings(PropName) = ConvertedValue
My.Settings.Save()

I have confirmed that the ConvertedValue is actually saved immediately after that code executes by looking at Settings.settings in a text editor. However, when I close the app, then check Settings.settings again, the value has reverted to its original value.

I have noted that the settings values exist in at least four places: Settings.settings, Settings.Designer.vb, HIPPO.vbproj.user and app.config. I presume that one of these files is overwriting the changes the app has made.

Alsdo, note that I have set "SaveMySettingsOnExit" to "false" in Application.myapp although that value might be overridden elsewhere.

What needs to be done to preserve a change to a settings value?

Developer technologies | VB
0 comments

2 answers

Sort by: Oldest
Most helpful Newest Oldest

  1. AI answer

    2026-04-14T12:11:06.3+00:00

    My.Settings.Save() persists only user‑scoped settings to the per‑user user.config file at run time. The design‑time files (Settings.settings, Settings.Designer.vb, *.vbproj.user, app.config) are not updated by My.Settings.Save and will always show the original design‑time values.

    Key points:

    1. Settings.settings, Settings.Designer.vb, *.vbproj.user, and app.config are design‑time artifacts
      • These files are edited in Visual Studio (Project → Properties → Settings) and compiled into the application.
      • They are not the files that My.Settings.Save() writes to at run time.
      • After the app runs and saves settings, the updated values are stored in a user.config file under the user profile, not back into Settings.settings or app.config.
    2. Only user‑scope settings are writable at run time
      • Application‑scope settings are read‑only in code.
      • User‑scope settings are read/write and can be changed and persisted with My.Settings.Save().
      • If PropName refers to an application‑scope setting, the value will not be persisted as a user change.
    3. SaveMySettingsOnExit is only about automatic saving on shutdown
      • My.Application.SaveMySettingsOnExit = False just disables the automatic save when the app exits.
      • Explicit calls to My.Settings.Save() still persist user‑scope settings regardless of SaveMySettingsOnExit.
    4. How to correctly persist and verify changes
      • Ensure the setting’s Scope is User in the Project Designer (Settings tab).
      • Change the value in code: 
             My.Settings(PropName) = ConvertedValue
     My.Settings.Save()
      • Do not expect Settings.settings or app.config to change; instead, read the value back via My.Settings in a new run of the application: 
             Dim currentValue = My.Settings(PropName)
      • If needed, locate and inspect the generated user.config file (this is where the runtime changes are stored).
    5. If values appear to “revert”
      • The apparent revert is usually because the design‑time files are being inspected instead of the runtime user.config.
      • As long as the setting is user‑scoped and My.Settings.Save() is called, the user’s changes are preserved between runs, independent of the design‑time defaults.

    References:

    AI-generated content may be incorrect. Read our transparency notes for more information.

    Was this answer helpful?

  2. Jack Dang (WICLOUD CORPORATION) 18,975 Reputation points Microsoft External Staff Moderator
    2026-04-15T03:42:53.7233333+00:00

    Hi @RogerSchlueter-7899 ,

    Thanks for reaching out.

    The thing to clarify here is where .NET actually persists settings at runtime, because it’s a bit different from what it looks like in the project files.

    Files like Settings.settings, Settings.Designer.vb, and app.config are design-time artifacts. They define the default values that ship with your application, but they are not updated when your code calls My.Settings.Save(). So checking those files after closing the app will always show the original values, which can make it seem like nothing was saved.

    When you call My.Settings.Save(), the updated values are written to a per-user file called user.config, which lives under your AppData folder (for example under C:\Users\<user>\AppData\Local\<app>\...).

    Because of that, two things are important to verify. First, make sure the setting you’re updating is defined with User scope in Settings.settings. Only user-scoped settings are persisted to user.config. If PropName refers to an Application-scoped setting, it is not intended to be changed and persisted at runtime, so the value will not be preserved across launches.

    Second, under normal behavior, My.Settings.Save() does not write back to Settings.settings, so if that file appears to change, the change is likely coming from design-time tooling or some other process rather than runtime persistence.

    Your SaveMySettingsOnExit = false setting is fine in this scenario since you’re explicitly calling Save(), so it won’t prevent persistence.

    Once the setting is user-scoped and you look at the user.config location instead of the project files, you should see that the value is being preserved correctly between runs.

    Hope this helps! If my explanation and information I provided were useful, I would greatly appreciate it if you could follow the instructions here so others with the same problem can benefit as well.

    Was this answer helpful?

Your answer

Answers can be marked as 'Accepted' by the question author and 'Recommended' by moderators, which helps users know the answer solved the author's problem.