Skip restoring a toggle already in its remembered state [patch]

TrayApp.Test/TrayAppBuilderTests.cs

@@ -161,7 +161,7 @@
 	}
 
 	[TestMethod]
 	public void Preferences_WithTheLongestDebounce_IsAcceptedAndATimerTakesIt()
 	{
 		InMemoryPersistenceProvider<string> provider = new();
 		TrayAppDefinition app = TrayAppBuilder.Create("demo")
@@ -200,6 +200,67 @@
 		Assert.IsFalse(forgotten);
 	}
 
+	[TestMethod]
+	[DataRow(false)]
+	[DataRow(true)]
+	public async Task LoadPreferences_WhenTheToggleIsAlreadyInTheRememberedState_DoesNotCallTheSetter(bool state)
+	{
+		InMemoryPersistenceProvider<string> provider = new();
+
+		using (DebouncedPreferenceStore seed = new(provider, "tray", Debounce))
+		{
+			await seed.LoadAsync().ConfigureAwait(false);
+			seed.Set("awake", state);
+			await seed.FlushAsync().ConfigureAwait(false);
+		}
+
+		bool awake = state;
+		int setterCalls = 0;
+
+		// The setter ignores its argument and flips, as the class example's does.
+		TrayAppDefinition app = TrayAppBuilder.Create("demo")
+			.Toggle("Keep awake", () => awake, _ =>
+			{
+				setterCalls++;
+				awake = !awake;
+			}, persistAs: "awake")
+			.Preferences(provider)
+			.Build();
+
+		using DebouncedPreferenceStore store = new(provider, "tray", Debounce);
+
+		Assert.IsNull(TrayAppBuilder.LoadPreferences(app, store));
+		Assert.AreEqual(state, awake);
+		Assert.AreEqual(0, setterCalls);
+	}
+
+	[TestMethod]
+	public async Task LoadPreferences_WhenTheGetterThrows_KeepsGoingAndHandsBackTheMessage()
+	{
+		InMemoryPersistenceProvider<string> provider = new();
+
+		using (DebouncedPreferenceStore seed = new(provider, "tray", Debounce))
+		{
+			await seed.LoadAsync().ConfigureAwait(false);
+			seed.Set("awake", true);
+			seed.Set("display", true);
+			await seed.FlushAsync().ConfigureAwait(false);
+		}
+
+		bool display = false;
+
+		TrayAppDefinition app = TrayAppBuilder.Create("demo")
+			.Toggle("Keep awake", () => throw new InvalidOperationException("no inhibitor here"), _ => { }, persistAs: "awake")
+			.Toggle("Keep display awake", () => display, value => display = value, persistAs: "display")
+			.Preferences(provider)
+			.Build();
+
+		using DebouncedPreferenceStore store = new(provider, "tray", Debounce);
+
+		Assert.AreEqual("no inhibitor here", TrayAppBuilder.LoadPreferences(app, store));
+		Assert.IsTrue(display);
+	}
+
 	[TestMethod]
 	public async Task LoadPreferences_ThenOptions_LetsAnExplicitSwitchWin()
 	{

TrayApp/Menu/TrayToggleItem.cs

@@ -63,6 +63,12 @@ public override void Refresh()
 	/// </remarks>
 	public void Set(bool value) => setState(value);
 
+	/// <summary>
+	/// Reads what the tool currently reports, without touching <see cref="IsChecked"/>.
+	/// </summary>
+	/// <returns>The getter's value. The getter belongs to the tool and may throw.</returns>
+	internal bool ReadState() => getState();
+
 	/// <summary>
 	/// Sets the toggle to the opposite of what the tool currently reports.
 	/// </summary>

TrayApp/TrayAppBuilder.cs

@@ -535,7 +535,13 @@ private static async Task<int> FinishAsync(int exitCode, DebouncedPreferenceStor
 
 			try
 			{
-				toggle.Set(remembered);
+				// A restore asks for a state, where a click asks for a change, so a toggle already in the
+				// remembered state is left alone: a setter written as a flip (as the class example's is) would
+				// otherwise invert it, and one that takes a resource would take it a second time.
+				if (toggle.ReadState() != remembered)
+				{
+					toggle.Set(remembered);
+				}
 			}
 			catch (Exception ex) when (FatalError.IsNotFatal(ex))
 			{