Merge pull request #4058 from Nexus-Mods/feat/1043-key-scoped-settings

erri120 · web-flow · commit 99330dab802c · 2025-10-28T12:59:18.000+01:00
Add support for key scoped settings
diff --git a/src/NexusMods.Backend/Settings/JsonStorageBackend.cs b/src/NexusMods.Backend/Settings/JsonStorageBackend.cs
@@ -46,10 +46,10 @@ private static AbsolutePath GetConfigsFolderPath(IFileSystem fileSystem)
         return fileSystem.GetKnownPath(baseKnownPath).Combine(baseDirectoryName);
     }
 
-    private AbsolutePath GetConfigPath<T>()
+    private AbsolutePath GetConfigPath<T>(string? key)
     {
         var typeName = typeof(T).FullName ?? typeof(T).Name;
-        var fileName = $"{typeName}.json";
+        var fileName = string.IsNullOrWhiteSpace(key) ? $"{typeName}.json" : $"{typeName}_{key}.json";
         return _configDirectory.Combine(fileName);
     }
 
@@ -80,17 +80,17 @@ private void Serialize<T>(Stream stream ,T value) where T : class
     }
 
     /// <inheritdoc/>
-    public void Save<T>(T value) where T : class, ISettings, new()
+    public void Save<T>(T value, string? key) where T : class, ISettings, new()
     {
-        var configPath = GetConfigPath<T>();
+        var configPath = GetConfigPath<T>(key);
         using var stream = configPath.Open(FileMode.Create, FileAccess.ReadWrite, FileShare.None);
         Serialize(stream, value);
     }
 
     /// <inheritdoc/>
-    public T? Load<T>() where T : class, ISettings, new()
+    public T? Load<T>(string? key) where T : class, ISettings, new()
     {
-        var configPath = GetConfigPath<T>();
+        var configPath = GetConfigPath<T>(key);
         if (!configPath.FileExists) return null;
 
         using var stream = configPath.Open(FileMode.Open, FileAccess.Read, FileShare.Read);
diff --git a/src/NexusMods.Backend/Settings/MnemonicDBStorageBackend.cs b/src/NexusMods.Backend/Settings/MnemonicDBStorageBackend.cs
@@ -52,17 +52,18 @@ public MnemonicDBStorageBackend(IServiceProvider serviceProvider)
         }
     }
 
-    private static string GetId<T>() where T : ISettings
+    private static string GetId<T>(string? key) where T : ISettings
     {
-        return typeof(T).FullName ?? typeof(T).Name;
+        var typeName = typeof(T).FullName ?? typeof(T).Name;
+        return string.IsNullOrWhiteSpace(key) ? typeName : $"{typeName}|{key}";
     }
 
-    public async ValueTask Save<T>(T value, CancellationToken cancellationToken) where T : class, ISettings, new()
+    public async ValueTask Save<T>(T value, string? key, CancellationToken cancellationToken) where T : class, ISettings, new()
     {
         var db = _conn.Value.Db;
         using var tx = _conn.Value.BeginTransaction();
 
-        var name = GetId<T>();
+        var name = GetId<T>(key);
 
         EntityId id;
         var settings = Setting.FindByName(db, name).ToArray();
@@ -80,9 +81,9 @@ private static string GetId<T>() where T : ISettings
         await tx.Commit();
     }
 
-    public ValueTask<T?> Load<T>(CancellationToken cancellationToken) where T : class, ISettings, new()
+    public ValueTask<T?> Load<T>(string? key, CancellationToken cancellationToken) where T : class, ISettings, new()
     {
-        var settings = Setting.FindByName(_conn.Value.Db, GetId<T>()).ToArray();
+        var settings = Setting.FindByName(_conn.Value.Db, GetId<T>(key)).ToArray();
         if (settings.Length == 0) return ValueTask.FromResult<T?>(null);
         return ValueTask.FromResult(Deserialize<T>(settings.First().Value));
     }
diff --git a/src/NexusMods.Backend/Settings/SettingsManager.cs b/src/NexusMods.Backend/Settings/SettingsManager.cs
@@ -15,8 +15,8 @@ internal class SettingsManager : ISettingsManager
     private readonly IServiceProvider _serviceProvider;
     private readonly ILogger _logger;
 
-    private readonly Subject<(Type, object)> _subject = new();
-    private readonly Dictionary<Type, object> _values = new();
+    private readonly Subject<(SettingKey, object)> _subject = new();
+    private readonly Dictionary<SettingKey, object> _values = new();
 
     private readonly FrozenDictionary<Type, Func<object, object>> _overrides;
 
@@ -78,37 +78,38 @@ public SettingsManager(IServiceProvider serviceProvider)
         _asyncStorageBackendMappings = asyncStorageBackendMappings.ToFrozenDictionary();
     }
 
-    private void CoreSet<T>(T value, bool notify) where T : class, ISettings, new()
+    private void CoreSet<T>(T value, SettingKey settingKey, bool notify) where T : class, ISettings, new()
     {
-        var type = typeof(T);
-        _values[type] = value;
+        _values[settingKey] = value;
         if (!notify) return;
 
-        _subject.OnNext((type, value));
-        Save(value);
+        _subject.OnNext((settingKey, value));
+        Save(value, settingKey.Key);
     }
  
-    public void Set<T>(T value) where T : class, ISettings, new() => CoreSet(value, notify: true);
+    public void Set<T>(T value, string? key) where T : class, ISettings, new() => CoreSet(value, new SettingKey(typeof(T), key), notify: true);
 
-    public T Get<T>() where T : class, ISettings, new()
+    public T Get<T>(string? key) where T : class, ISettings, new()
     {
-        if (_values.TryGetValue(typeof(T), out var obj))
+        var settingKey = new SettingKey(typeof(T), key);
+        
+        if (_values.TryGetValue(settingKey, out var obj))
         {
             Debug.Assert(obj is T);
             return (obj as T)!;
         }
 
-        var savedValue = Load<T>();
+        var savedValue = Load<T>(key);
         if (savedValue is not null)
         {
             savedValue = Override(savedValue, out _);
-            CoreSet(savedValue, notify: false);
+            CoreSet(savedValue, settingKey, notify: false);
             return savedValue;
         }
 
         var defaultValue = GetDefault<T>();
         defaultValue = Override(defaultValue, out var didOverride);
-        CoreSet(defaultValue, notify: !didOverride);
+        CoreSet(defaultValue, settingKey, notify: !didOverride);
 
         return defaultValue;
 
@@ -146,49 +147,51 @@ private object GetDefault(Type settingsType)
         return defaultValue;
     }
 
-    public T Update<T>(Func<T, T> updater) where T : class, ISettings, new()
+    public T Update<T>(Func<T, T> updater, string? key) where T : class, ISettings, new()
     {
-        var currentValue = Get<T>();
+        var currentValue = Get<T>(key);
         var newValue = updater(currentValue);
-        Set(newValue);
+        Set(newValue, key);
 
         return newValue;
     }
 
-    public Observable<T> GetChanges<T>(bool prependCurrent = false) where T : class, ISettings, new()
+    public Observable<T> GetChanges<T>(string? key, bool prependCurrent = false) where T : class, ISettings, new()
     {
+        var settingKey = new SettingKey(typeof(T), key);
+        
         var result = _subject
-            .Where(tuple => tuple.Item1 == typeof(T))
+            .Where(settingKey, static (tuple, state) => tuple.Item1 == state)
             .Select(tuple => (tuple.Item2 as T)!);
 
-        return prependCurrent ? result.Prepend(Get<T>()) : result;
+        return prependCurrent ? result.Prepend(Get<T>(key)) : result;
     }
 
 #region Save/Load
 
-    private void Save<T>(T value) where T : class, ISettings, new()
+    private void Save<T>(T value, string? key) where T : class, ISettings, new()
     {
         var type = typeof(T);
 
         if (_storageBackendMappings.TryGetValue(type, out var storageBackend))
         {
             try
             {
-                storageBackend.Save(value);
+                storageBackend.Save(value, key);
             }
             catch (Exception e)
             {
                 _logger.LogError(e, "Exception while saving settings type `{Type}` with storage backend `{StorageBackendType}`", type, storageBackend.GetType());
             }
         } else if (_asyncStorageBackendMappings.TryGetValue(type, out var asyncStorageBackend))
         {
-            Scheduler.ScheduleAsync((value, asyncStorageBackend, _logger), TimeSpan.Zero, async static (_, state, cancellationToken) =>
+            Scheduler.ScheduleAsync((value, key, asyncStorageBackend, _logger), TimeSpan.Zero, async static (_, state, cancellationToken) =>
             {
-                var (valueToSave, backend, logger) = state;
+                var (valueToSave, stringKey, backend, logger) = state;
 
                 try
                 {
-                    await backend.Save(valueToSave, cancellationToken);
+                    await backend.Save(valueToSave, stringKey, cancellationToken);
                 }
                 catch (Exception e)
                 {
@@ -198,15 +201,15 @@ private object GetDefault(Type settingsType)
         }
     }
 
-    private T? Load<T>() where T : class, ISettings, new()
+    private T? Load<T>(string? key) where T : class, ISettings, new()
     {
         var type = typeof(T);
 
         if (_storageBackendMappings.TryGetValue(type, out var storageBackend))
         {
             try
             {
-                return storageBackend.Load<T>();
+                return storageBackend.Load<T>(key);
             }
             catch (Exception e)
             {
@@ -223,7 +226,7 @@ private object GetDefault(Type settingsType)
             {
                 try
                 {
-                    res = await asyncStorageBackend.Load<T>(cts.Token);
+                    res = await asyncStorageBackend.Load<T>(key, cts.Token);
                     waitHandle.Set();
                 }
                 catch (Exception e)
diff --git a/src/NexusMods.Sdk/Settings/Backend/IAsyncStorageBackend.cs b/src/NexusMods.Sdk/Settings/Backend/IAsyncStorageBackend.cs
@@ -12,7 +12,7 @@ public interface IAsyncStorageBackend : IBaseStorageBackend, IAsyncDisposable
     /// <summary>
     /// Saves the given settings object to the storage backend asynchronously.
     /// </summary>
-    ValueTask Save<T>(T value, CancellationToken cancellationToken) where T : class, ISettings, new();
+    ValueTask Save<T>(T value, string? key, CancellationToken cancellationToken) where T : class, ISettings, new();
 
     /// <summary>
     /// Loads the given settings type from the storage backend asynchronously.
@@ -21,5 +21,5 @@ public interface IAsyncStorageBackend : IBaseStorageBackend, IAsyncDisposable
     /// Either the loaded value or <c>null</c> if the loading failed
     /// or the storage backend doesn't contain this value.
     /// </returns>
-    ValueTask<T?> Load<T>(CancellationToken cancellationToken) where T : class, ISettings, new();
+    ValueTask<T?> Load<T>(string? key, CancellationToken cancellationToken) where T : class, ISettings, new();
 }
diff --git a/src/NexusMods.Sdk/Settings/Backend/IStorageBackend.cs b/src/NexusMods.Sdk/Settings/Backend/IStorageBackend.cs
@@ -12,7 +12,7 @@ public interface IStorageBackend : IBaseStorageBackend, IDisposable
     /// <summary>
     /// Saves the given settings object to the storage backend synchronously.
     /// </summary>
-    void Save<T>(T value) where T : class, ISettings, new();
+    void Save<T>(T value, string? key) where T : class, ISettings, new();
 
     /// <summary>
     /// Loads the given settings type from the storage backend synchronously.
@@ -21,5 +21,5 @@ public interface IStorageBackend : IBaseStorageBackend, IDisposable
     /// Either the loaded value or <c>null</c> if the loading failed
     /// or the storage backend doesn't contain this value.
     /// </returns>
-    T? Load<T>() where T : class, ISettings, new();
+    T? Load<T>(string? key) where T : class, ISettings, new();
 }
diff --git a/src/NexusMods.Sdk/Settings/ISettingsManager.cs b/src/NexusMods.Sdk/Settings/ISettingsManager.cs
@@ -13,13 +13,13 @@ public interface ISettingsManager
     /// <summary>
     /// Sets the current value of <typeparamref name="T"/>.
     /// </summary>
-    void Set<T>(T value) where T : class, ISettings, new();
+    void Set<T>(T value, string? key = null) where T : class, ISettings, new();
 
     /// <summary>
     /// Gets the current value for <typeparamref name="T"/>.
     /// </summary>
     /// <returns>The current value.</returns>
-    T Get<T>() where T : class, ISettings, new();
+    T Get<T>(string? key = null) where T : class, ISettings, new();
 
     /// <summary>
     /// Gets the default value for <typeparamref name="T"/>.
@@ -35,12 +35,12 @@ public interface ISettingsManager
     /// value will be ignored, unless the modified input value gets returned.
     /// </param>
     /// <returns>The updated value.</returns>
-    T Update<T>(Func<T, T> updater) where T : class, ISettings, new();
+    T Update<T>(Func<T, T> updater, string? key = null) where T : class, ISettings, new();
 
     /// <summary>
     /// Gets an observable stream to be notified about changes to <typeparamref name="T"/>.
     /// </summary>
-    Observable<T> GetChanges<T>(bool prependCurrent) where T : class, ISettings, new();
+    Observable<T> GetChanges<T>(string? key = null, bool prependCurrent = false) where T : class, ISettings, new();
 
     /// <summary>
     /// Gets configs for all registered settings.
diff --git a/src/NexusMods.Sdk/Settings/SettingKey.cs b/src/NexusMods.Sdk/Settings/SettingKey.cs
@@ -0,0 +1,7 @@
+namespace NexusMods.Sdk.Settings;
+
+
+/// <summary>
+/// Identifies a setting by its type and an optional scope key.
+/// </summary>
+public readonly record struct SettingKey(Type SettingType, string? Key);

Original file line number	Diff line number	Diff line change
`@@ -46,10 +46,10 @@ private static AbsolutePath GetConfigsFolderPath(IFileSystem fileSystem)`
`46`	`46`	`return fileSystem.GetKnownPath(baseKnownPath).Combine(baseDirectoryName);`
`47`	`47`	`}`
`48`	`48`
`49`		`- private AbsolutePath GetConfigPath<T>()`
	`49`	`+ private AbsolutePath GetConfigPath<T>(string? key)`
`50`	`50`	`{`
`51`	`51`	`var typeName = typeof(T).FullName ?? typeof(T).Name;`
`52`		`- var fileName = $"{typeName}.json";`
	`52`	`+ var fileName = string.IsNullOrWhiteSpace(key) ? $"{typeName}.json" : $"{typeName}_{key}.json";`
`53`	`53`	`return _configDirectory.Combine(fileName);`
`54`	`54`	`}`
`55`	`55`
`@@ -80,17 +80,17 @@ private void Serialize<T>(Stream stream ,T value) where T : class`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`/// <inheritdoc/>`
`83`		`- public void Save<T>(T value) where T : class, ISettings, new()`
	`83`	`+ public void Save<T>(T value, string? key) where T : class, ISettings, new()`
`84`	`84`	`{`
`85`		`- var configPath = GetConfigPath<T>();`
	`85`	`+ var configPath = GetConfigPath<T>(key);`
`86`	`86`	`using var stream = configPath.Open(FileMode.Create, FileAccess.ReadWrite, FileShare.None);`
`87`	`87`	`Serialize(stream, value);`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`/// <inheritdoc/>`
`91`		`- public T? Load<T>() where T : class, ISettings, new()`
	`91`	`+ public T? Load<T>(string? key) where T : class, ISettings, new()`
`92`	`92`	`{`
`93`		`- var configPath = GetConfigPath<T>();`
	`93`	`+ var configPath = GetConfigPath<T>(key);`
`94`	`94`	`if (!configPath.FileExists) return null;`
`95`	`95`
`96`	`96`	`using var stream = configPath.Open(FileMode.Open, FileAccess.Read, FileShare.Read);`
Original file line number	Diff line number	Diff line change
`@@ -52,17 +52,18 @@ public MnemonicDBStorageBackend(IServiceProvider serviceProvider)`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`		`- private static string GetId<T>() where T : ISettings`
	`55`	`+ private static string GetId<T>(string? key) where T : ISettings`
`56`	`56`	`{`
`57`		`- return typeof(T).FullName ?? typeof(T).Name;`
	`57`	`+ var typeName = typeof(T).FullName ?? typeof(T).Name;`
	`58`	`+ return string.IsNullOrWhiteSpace(key) ? typeName : $"{typeName}\|{key}";`
`58`	`59`	`}`
`59`	`60`
`60`		`- public async ValueTask Save<T>(T value, CancellationToken cancellationToken) where T : class, ISettings, new()`
	`61`	`+ public async ValueTask Save<T>(T value, string? key, CancellationToken cancellationToken) where T : class, ISettings, new()`
`61`	`62`	`{`
`62`	`63`	`var db = _conn.Value.Db;`
`63`	`64`	`using var tx = _conn.Value.BeginTransaction();`
`64`	`65`
`65`		`- var name = GetId<T>();`
	`66`	`+ var name = GetId<T>(key);`
`66`	`67`
`67`	`68`	`EntityId id;`
`68`	`69`	`var settings = Setting.FindByName(db, name).ToArray();`
`@@ -80,9 +81,9 @@ private static string GetId<T>() where T : ISettings`
`80`	`81`	`await tx.Commit();`
`81`	`82`	`}`
`82`	`83`
`83`		`- public ValueTask<T?> Load<T>(CancellationToken cancellationToken) where T : class, ISettings, new()`
	`84`	`+ public ValueTask<T?> Load<T>(string? key, CancellationToken cancellationToken) where T : class, ISettings, new()`
`84`	`85`	`{`
`85`		`- var settings = Setting.FindByName(_conn.Value.Db, GetId<T>()).ToArray();`
	`86`	`+ var settings = Setting.FindByName(_conn.Value.Db, GetId<T>(key)).ToArray();`
`86`	`87`	`if (settings.Length == 0) return ValueTask.FromResult<T?>(null);`
`87`	`88`	`return ValueTask.FromResult(Deserialize<T>(settings.First().Value));`
`88`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,8 +15,8 @@ internal class SettingsManager : ISettingsManager`
`15`	`15`	`private readonly IServiceProvider _serviceProvider;`
`16`	`16`	`private readonly ILogger _logger;`
`17`	`17`
`18`		`- private readonly Subject<(Type, object)> _subject = new();`
`19`		`- private readonly Dictionary<Type, object> _values = new();`
	`18`	`+ private readonly Subject<(SettingKey, object)> _subject = new();`
	`19`	`+ private readonly Dictionary<SettingKey, object> _values = new();`
`20`	`20`
`21`	`21`	`private readonly FrozenDictionary<Type, Func<object, object>> _overrides;`
`22`	`22`
`@@ -78,37 +78,38 @@ public SettingsManager(IServiceProvider serviceProvider)`
`78`	`78`	`_asyncStorageBackendMappings = asyncStorageBackendMappings.ToFrozenDictionary();`
`79`	`79`	`}`
`80`	`80`
`81`		`- private void CoreSet<T>(T value, bool notify) where T : class, ISettings, new()`
	`81`	`+ private void CoreSet<T>(T value, SettingKey settingKey, bool notify) where T : class, ISettings, new()`
`82`	`82`	`{`
`83`		`- var type = typeof(T);`
`84`		`- _values[type] = value;`
	`83`	`+ _values[settingKey] = value;`
`85`	`84`	`if (!notify) return;`
`86`	`85`
`87`		`- _subject.OnNext((type, value));`
`88`		`- Save(value);`
	`86`	`+ _subject.OnNext((settingKey, value));`
	`87`	`+ Save(value, settingKey.Key);`
`89`	`88`	`}`
`90`	`89`
`91`		`- public void Set<T>(T value) where T : class, ISettings, new() => CoreSet(value, notify: true);`
	`90`	`+ public void Set<T>(T value, string? key) where T : class, ISettings, new() => CoreSet(value, new SettingKey(typeof(T), key), notify: true);`
`92`	`91`
`93`		`- public T Get<T>() where T : class, ISettings, new()`
	`92`	`+ public T Get<T>(string? key) where T : class, ISettings, new()`
`94`	`93`	`{`
`95`		`- if (_values.TryGetValue(typeof(T), out var obj))`
	`94`	`+ var settingKey = new SettingKey(typeof(T), key);`
	`95`	`+`
	`96`	`+ if (_values.TryGetValue(settingKey, out var obj))`
`96`	`97`	`{`
`97`	`98`	`Debug.Assert(obj is T);`
`98`	`99`	`return (obj as T)!;`
`99`	`100`	`}`
`100`	`101`
`101`		`- var savedValue = Load<T>();`
	`102`	`+ var savedValue = Load<T>(key);`
`102`	`103`	`if (savedValue is not null)`
`103`	`104`	`{`
`104`	`105`	`savedValue = Override(savedValue, out _);`
`105`		`- CoreSet(savedValue, notify: false);`
	`106`	`+ CoreSet(savedValue, settingKey, notify: false);`
`106`	`107`	`return savedValue;`
`107`	`108`	`}`
`108`	`109`
`109`	`110`	`var defaultValue = GetDefault<T>();`
`110`	`111`	`defaultValue = Override(defaultValue, out var didOverride);`
`111`		`- CoreSet(defaultValue, notify: !didOverride);`
	`112`	`+ CoreSet(defaultValue, settingKey, notify: !didOverride);`
`112`	`113`
`113`	`114`	`return defaultValue;`
`114`	`115`
`@@ -146,49 +147,51 @@ private object GetDefault(Type settingsType)`
`146`	`147`	`return defaultValue;`
`147`	`148`	`}`
`148`	`149`
`149`		`- public T Update<T>(Func<T, T> updater) where T : class, ISettings, new()`
	`150`	`+ public T Update<T>(Func<T, T> updater, string? key) where T : class, ISettings, new()`
`150`	`151`	`{`
`151`		`- var currentValue = Get<T>();`
	`152`	`+ var currentValue = Get<T>(key);`
`152`	`153`	`var newValue = updater(currentValue);`
`153`		`- Set(newValue);`
	`154`	`+ Set(newValue, key);`
`154`	`155`
`155`	`156`	`return newValue;`
`156`	`157`	`}`
`157`	`158`
`158`		`- public Observable<T> GetChanges<T>(bool prependCurrent = false) where T : class, ISettings, new()`
	`159`	`+ public Observable<T> GetChanges<T>(string? key, bool prependCurrent = false) where T : class, ISettings, new()`
`159`	`160`	`{`
	`161`	`+ var settingKey = new SettingKey(typeof(T), key);`
	`162`	`+`
`160`	`163`	`var result = _subject`
`161`		`- .Where(tuple => tuple.Item1 == typeof(T))`
	`164`	`+ .Where(settingKey, static (tuple, state) => tuple.Item1 == state)`
`162`	`165`	`.Select(tuple => (tuple.Item2 as T)!);`
`163`	`166`
`164`		`- return prependCurrent ? result.Prepend(Get<T>()) : result;`
	`167`	`+ return prependCurrent ? result.Prepend(Get<T>(key)) : result;`
`165`	`168`	`}`
`166`	`169`
`167`	`170`	`#region Save/Load`
`168`	`171`
`169`		`- private void Save<T>(T value) where T : class, ISettings, new()`
	`172`	`+ private void Save<T>(T value, string? key) where T : class, ISettings, new()`
`170`	`173`	`{`
`171`	`174`	`var type = typeof(T);`
`172`	`175`
`173`	`176`	`if (_storageBackendMappings.TryGetValue(type, out var storageBackend))`
`174`	`177`	`{`
`175`	`178`	`try`
`176`	`179`	`{`
`177`		`- storageBackend.Save(value);`
	`180`	`+ storageBackend.Save(value, key);`
`178`	`181`	`}`
`179`	`182`	`catch (Exception e)`
`180`	`183`	`{`
`181`	`184`	_logger.LogError(e, "Exception while saving settings type `{Type}` with storage backend `{StorageBackendType}`", type, storageBackend.GetType());
`182`	`185`	`}`
`183`	`186`	`} else if (_asyncStorageBackendMappings.TryGetValue(type, out var asyncStorageBackend))`
`184`	`187`	`{`
`185`		`- Scheduler.ScheduleAsync((value, asyncStorageBackend, _logger), TimeSpan.Zero, async static (_, state, cancellationToken) =>`
	`188`	`+ Scheduler.ScheduleAsync((value, key, asyncStorageBackend, _logger), TimeSpan.Zero, async static (_, state, cancellationToken) =>`
`186`	`189`	`{`
`187`		`- var (valueToSave, backend, logger) = state;`
	`190`	`+ var (valueToSave, stringKey, backend, logger) = state;`
`188`	`191`
`189`	`192`	`try`
`190`	`193`	`{`
`191`		`- await backend.Save(valueToSave, cancellationToken);`
	`194`	`+ await backend.Save(valueToSave, stringKey, cancellationToken);`
`192`	`195`	`}`
`193`	`196`	`catch (Exception e)`
`194`	`197`	`{`
`@@ -198,15 +201,15 @@ private object GetDefault(Type settingsType)`
`198`	`201`	`}`
`199`	`202`	`}`
`200`	`203`
`201`		`- private T? Load<T>() where T : class, ISettings, new()`
	`204`	`+ private T? Load<T>(string? key) where T : class, ISettings, new()`
`202`	`205`	`{`
`203`	`206`	`var type = typeof(T);`
`204`	`207`
`205`	`208`	`if (_storageBackendMappings.TryGetValue(type, out var storageBackend))`
`206`	`209`	`{`
`207`	`210`	`try`
`208`	`211`	`{`
`209`		`- return storageBackend.Load<T>();`
	`212`	`+ return storageBackend.Load<T>(key);`
`210`	`213`	`}`
`211`	`214`	`catch (Exception e)`
`212`	`215`	`{`
`@@ -223,7 +226,7 @@ private object GetDefault(Type settingsType)`
`223`	`226`	`{`
`224`	`227`	`try`
`225`	`228`	`{`
`226`		`- res = await asyncStorageBackend.Load<T>(cts.Token);`
	`229`	`+ res = await asyncStorageBackend.Load<T>(key, cts.Token);`
`227`	`230`	`waitHandle.Set();`
`228`	`231`	`}`
`229`	`232`	`catch (Exception e)`