C# WinUI 3 ILocalSettingsService saving to file

Question

I am using WinUI 3 Template Studio, and somehow struggling with saving settings to file.

The LocalSettingsService comes as default with the template:

public class LocalSettingsService : ILocalSettingsService
{
    private const string _defaultApplicationDataFolder = "SettingsTest/ApplicationData";
    private const string _defaultLocalSettingsFile = "LocalSettings.json";

    private readonly IFileService _fileService;
    private readonly LocalSettingsOptions _options;

    private readonly string _localApplicationData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
    private readonly string _applicationDataFolder;
    private readonly string _localsettingsFile;

    private IDictionary<string, object> _settings;

    private bool _isInitialized;

    public LocalSettingsService(IFileService fileService, IOptions<LocalSettingsOptions> options)
    {
        _fileService = fileService;
        _options = options.Value;

        _applicationDataFolder = Path.Combine(_localApplicationData, _options.ApplicationDataFolder ?? _defaultApplicationDataFolder);
        _localsettingsFile = _options.LocalSettingsFile ?? _defaultLocalSettingsFile;

        _settings = new Dictionary<string, object>();
    }

    private async Task InitializeAsync()
    {
        if (!_isInitialized)
        {
            _settings = await Task.Run(() => _fileService.Read<IDictionary<string, object>>(_applicationDataFolder, _localsettingsFile)) ?? new Dictionary<string, object>();

            _isInitialized = true;
        }
    }

    public async Task<T?> ReadSettingAsync<T>(string key)
    {
        if (RuntimeHelper.IsMSIX)
        {
            if (ApplicationData.Current.LocalSettings.Values.TryGetValue(key, out var obj))
            {
                return await Json.ToObjectAsync<T>((string)obj);
            }
        }
        else
        {
            await InitializeAsync();

            if (_settings != null && _settings.TryGetValue(key, out var obj))
            {
                return await Json.ToObjectAsync<T>((string)obj);
            }
        }

        return default;
    }

    public async Task SaveSettingAsync<T>(string key, T value)
    {
        if (RuntimeHelper.IsMSIX)
        {
            ApplicationData.Current.LocalSettings.Values[key] = await Json.StringifyAsync(value);
        }
        else
        {
            await InitializeAsync();

            _settings[key] = await Json.StringifyAsync(value);

            await Task.Run(() => _fileService.Save(_applicationDataFolder, _localsettingsFile, _settings));
        }
    }
}

I have created a SettingsService that my app can access for various settings. Everything works great except the most important, it does not save the setting(s) to file.

public class SettingsService : ISettingsService
{
    #region Properties

    private const string AppPrimaryONKey = "AppIsPrimaryON";

    private readonly ILocalSettingsService localSettingsService;

    public bool PrimaryON { get; set; } = false;

    #endregion

    #region Constructor

    public SettingsService(ILocalSettingsService _localSettingsService)
    {
        localSettingsService = _localSettingsService;
    }

    #endregion

    public async Task InitializeAsync()
    {
        PrimaryON = await LoadPrimaryONFromSettingsAsync();
        await Task.CompletedTask;
    }

    #region PrimaryON
   
    public async Task SetPrimaryONAsync(bool value)
    {
        PrimaryON = value;
        await SavePrimaryONInSettingsAsync(value);
    }

    private async Task<bool> LoadPrimaryONFromSettingsAsync()
    {
        var primaryON = await localSettingsService.ReadSettingAsync<string>(AppPrimaryONKey);

        if (bool.TryParse(primaryON, out var value))
        {
            return value;
        }

        return PrimaryON;
    }

    private async Task SavePrimaryONInSettingsAsync(bool value)
    {
        await localSettingsService.SaveSettingAsync(AppPrimaryONKey, value.ToString());
    }

    #endregion
}

What am I forgetting?