chore: remove verbose timing logs, bump to 1.2.8-rc4

- Remove Stopwatch instrumentation and Verbose log calls from
  ContextMenu.cs, TrayIcon.cs, and AppContext.cs
- Simplify PowerScheme.SystemChanged log to omit IconUpdateElapsedMs
- Bump VersionSuffix from rc3 to rc4

Author: SebastianBecker2

PowerManagement/PowerManager.cs

@@ -1,6 +1,7 @@
 namespace PowerManagement;
 
 using System.Diagnostics;
+using Serilog;
 using Vanara.Extensions;
 using Vanara.InteropServices;
 using Vanara.PInvoke;
@@ -90,6 +91,8 @@ public static bool IsExecutionStateBlockingIdle()
 
     private bool disposedValue;
     private readonly SafeHPOWERNOTIFY powerSettingsChangedCallbackHandler;
+    private readonly object schemeDispatchLock = new();
+    private Guid? lastDispatchedSchemeGuid;
 
     // This variable must not be a local but instead have a lifetime
     // exceeding the registration of the callback initialized with
@@ -166,11 +169,41 @@ private Win32Error HandlePowerSettingsChanged(
             return Win32Error.NO_ERROR;
         }
 
+        Guid activeSchemeGuid;
         try
         {
-            OnActivePowerSchemeChanged(new Guid(setting.Data));
+            activeSchemeGuid = new Guid(setting.Data);
         }
-        catch (ArgumentException) { }
+        catch (ArgumentException)
+        {
+            return Win32Error.NO_ERROR;
+        }
+
+        lock (schemeDispatchLock)
+        {
+            if (lastDispatchedSchemeGuid == activeSchemeGuid)
+            {
+                return Win32Error.NO_ERROR;
+            }
+
+            lastDispatchedSchemeGuid = activeSchemeGuid;
+        }
+
+        _ = Task.Run(() =>
+        {
+            try
+            {
+                OnActivePowerSchemeChanged(activeSchemeGuid);
+            }
+            catch (Exception ex)
+            {
+                Log.Error(
+                    ex,
+                    "Unhandled exception in active power scheme change dispatch for scheme {PowerSchemeGuid}",
+                    activeSchemeGuid);
+            }
+        });
+
         return Win32Error.NO_ERROR;
     }
 

PowerPlanSwitcher/AppContext.cs

@@ -1,6 +1,7 @@
 namespace PowerPlanSwitcher;
 
 using System.Configuration;
+using System.Threading;
 using PowerManagement;
 using PowerPlanSwitcher.Properties;
 using ProcessManagement;
@@ -13,7 +14,9 @@ internal class AppContext : ApplicationContext
 {
     private IPowerManager PowerManager { get; init; }
     private TrayIcon TrayIcon { get; init; }
+    private SynchronizationContext UiSynchronizationContext { get; }
     private Guid BaselineSchemeGuid { get; set; }
+    private Guid LastHandledSystemSchemeGuid { get; set; }
 
     public AppContext(
         TrayIcon trayIcon,
@@ -25,35 +28,19 @@ public AppContext(
     {
         TrayIcon = trayIcon;
         PowerManager = powerManager;
+        UiSynchronizationContext =
+            SynchronizationContext.Current
+            ?? new WindowsFormsSynchronizationContext();
 
         BaselineSchemeGuid = powerManager.GetActivePowerSchemeGuid();
+        LastHandledSystemSchemeGuid = BaselineSchemeGuid;
 
         ToastDlg.Initialize();
 
-        powerManager.ActivePowerSchemeChanged +=
-            (s, e) => trayIcon.UpdateIcon(e.ActiveSchemeGuid);
-
-        powerManager.ActivePowerSchemeChanged += (s, e) =>
-            Log.ForContext("EventType", "PowerScheme.SystemChanged")
-                .Information(
-                "System activated power scheme: {PowerSchemeName} {PowerSchemeGuid}",
-                powerManager.GetPowerSchemeName(e.ActiveSchemeGuid) ?? "<No Name>",
-                e.ActiveSchemeGuid);
-
         powerManager.ActivePowerSchemeChanged += (s, e) =>
-        {
-            if (ruleManager.AppliedRule is not null)
-            {
-                return;
-            }
-
-            if (e.ActiveSchemeGuid == Guid.Empty)
-            {
-                return;
-            }
-
-            BaselineSchemeGuid = e.ActiveSchemeGuid;
-        };
+            UiSynchronizationContext.Post(
+                _ => HandleSystemPowerSchemeChanged(ruleManager, e.ActiveSchemeGuid),
+                null);
 
         ruleManager.RuleApplicationChanged +=
             RuleManager_RuleApplicationChanged;
@@ -70,6 +57,44 @@ public AppContext(
         ruleManager.StartMonitoring();
     }
 
+    private void HandleSystemPowerSchemeChanged(
+        RuleManager ruleManager,
+        Guid activeSchemeGuid)
+    {
+        if (activeSchemeGuid == LastHandledSystemSchemeGuid)
+        {
+            return;
+        }
+
+        try
+        {
+            TrayIcon.UpdateIcon(activeSchemeGuid);
+        }
+        catch (ObjectDisposedException)
+        {
+            return;
+        }
+
+        LastHandledSystemSchemeGuid = activeSchemeGuid;
+
+        Log.ForContext("EventType", "PowerScheme.SystemChanged")
+            .Information(
+            "System activated power scheme: {PowerSchemeGuid}",
+            activeSchemeGuid);
+
+        if (ruleManager.AppliedRule is not null)
+        {
+            return;
+        }
+
+        if (activeSchemeGuid == Guid.Empty)
+        {
+            return;
+        }
+
+        BaselineSchemeGuid = activeSchemeGuid;
+    }
+
     private void Default_SettingChanging(
         object sender,
         SettingChangingEventArgs e)

PowerPlanSwitcher/ContextMenu.cs

@@ -2,69 +2,137 @@ namespace PowerPlanSwitcher;
 
 using Hotkeys;
 using PowerManagement;
+using PowerPlanSwitcher.Properties;
 using Serilog;
 
 internal class ContextMenu : ContextMenuStrip
 {
+    private sealed record PowerSchemeMenuEntry(
+        Guid Guid,
+        string? Name,
+        Image? Icon,
+        bool Visible);
+
     private HotkeyManager HotkeyManager { get; init; }
     private Func<SettingsDlg> SettingsDlgFactory { get; init; }
+    private IPowerManager PowerManager { get; init; }
+    private Guid ActiveSchemeGuid { get; set; }
+    private bool IsMenuDirty { get; set; }
+    private readonly List<(Guid guid, ToolStripMenuItem menuItem, string label)> schemeButtons = [];
 
     public ContextMenu(
         HotkeyManager hotkeyManager,
+        IPowerManager powerManager,
         Func<SettingsDlg> settingsDlgFactory)
     {
         HotkeyManager = hotkeyManager;
+        PowerManager = powerManager;
         SettingsDlgFactory = settingsDlgFactory;
+        ActiveSchemeGuid = powerManager.GetActivePowerSchemeGuid();
+        IsMenuDirty = false;
+
+        powerManager.ActivePowerSchemeChanged += (_, e) =>
+            ActiveSchemeGuid = e.ActiveSchemeGuid;
+        Settings.Default.PropertyChanged += (_, e) =>
+        {
+            if (string.Equals(
+                e.PropertyName,
+                nameof(Settings.Default.PowerSchemeSettings),
+                StringComparison.Ordinal))
+            {
+                IsMenuDirty = true;
+            }
+        };
 
         BuildContextMenu();
 
-        Opening += (s, e) => BuildContextMenu();
+        Opening += (s, e) =>
+        {
+            if (IsMenuDirty)
+            {
+                BuildContextMenu();
+            }
+            else
+            {
+                RefreshPowerSchemeButtons();
+            }
+        };
     }
 
     private void BuildContextMenu()
     {
+        var activeSchemeGuid = ActiveSchemeGuid;
+
         Items.Clear();
-        AddPowerSchemes();
+        schemeButtons.Clear();
+
+        AddPowerSchemes(activeSchemeGuid);
         _ = Items.Add(new ToolStripSeparator());
         AddSettingsButton();
         AddAboutButton();
         _ = Items.Add(new ToolStripSeparator());
         AddCloseButton();
+
+        IsMenuDirty = false;
     }
 
-    private void AddPowerSchemes()
+    private void RefreshPowerSchemeButtons()
     {
-        var activeSchemeGuid = PowerManager.Static.GetActivePowerSchemeGuid();
-        foreach (var (guid, name) in PowerManager.Static.GetPowerSchemes())
+        var activeSchemeGuid = ActiveSchemeGuid;
+        foreach (var (guid, menuItem, label) in schemeButtons)
         {
-            var setting = PowerSchemeSettings.GetSetting(guid);
-            if (setting is not null && !setting.Visible)
+            menuItem.Text = (guid == activeSchemeGuid ? "(Active) " : string.Empty) + label;
+        }
+    }
+
+    private void AddPowerSchemes(Guid activeSchemeGuid)
+    {
+        foreach (var scheme in GetPowerSchemeEntries())
+        {
+            if (!scheme.Visible)
             {
                 continue;
             }
 
             var button = new ToolStripMenuItem
             {
-                Image = setting?.Icon,
-                Text = (activeSchemeGuid == guid ? "(Active) " : string.Empty)
-                    + (name ?? guid.ToString()),
+                Image = scheme.Icon,
+                Text = (activeSchemeGuid == scheme.Guid ? "(Active) " : string.Empty)
+                    + (scheme.Name ?? scheme.Guid.ToString()),
             };
 
+            var label = scheme.Name ?? scheme.Guid.ToString();
+            schemeButtons.Add((scheme.Guid, button, label));
+
             button.Click += (_, _) =>
             {
                 Log.ForContext("EventType", "PowerScheme.ActivationRequested")
                     .Information(
                     "Activating power scheme: {PowerSchemeName} " +
                     "{PowerSchemeGuid} Reason: User selection",
-                    name,
-                    guid);
-                _ = PowerManager.Static.SetActivePowerSchemeAsync(guid);
+                    scheme.Name,
+                    scheme.Guid);
+                _ = PowerManager.SetActivePowerSchemeAsync(scheme.Guid);
             };
 
             _ = Items.Add(button);
         }
     }
 
+    private IEnumerable<PowerSchemeMenuEntry> GetPowerSchemeEntries()
+    {
+        foreach (var (guid, name) in PowerManager.GetPowerSchemes())
+        {
+            var setting = PowerSchemeSettings.GetSetting(guid);
+
+            yield return new PowerSchemeMenuEntry(
+                guid,
+                name,
+                setting?.Icon,
+                setting?.Visible ?? true);
+        }
+    }
+
     private void AddSettingsButton()
     {
         var button = new ToolStripMenuItem

PowerPlanSwitcher/PowerPlanSwitcher.csproj

@@ -7,7 +7,7 @@
     <ApplicationHighDpiMode>PerMonitorV2</ApplicationHighDpiMode>
     <ImplicitUsings>enable</ImplicitUsings>
     <VersionPrefix>1.2.8</VersionPrefix>
-    <VersionSuffix>rc3</VersionSuffix>
+    <VersionSuffix>rc4</VersionSuffix>
     <ApplicationIcon>Resources\power_surge.ico</ApplicationIcon>
     <Description>Tray-Icon tool to show the currently selected windows power plan, switch it manually and automatically.