refactor: renaming and utilities

Author: DearVa

src/Everywhere.Windows/Services/Win32NativeHelper.cs

@@ -149,7 +149,7 @@ public void SetWindowHitTestInvisible(Window window)
         PInvoke.SetLayeredWindowAttributes(hWnd, new COLORREF(), 255, LAYERED_WINDOW_ATTRIBUTES_FLAGS.LWA_ALPHA);
     }
 
-    private readonly Dictionary<nint, CompositionContext> compositionContexts = [];
+    private readonly Dictionary<nint, CompositionContext> _compositionContexts = [];
 
     // Modify from WPF source code
     // https://referencesource.microsoft.com/#PresentationFramework/src/Framework/System/Windows/Shell/WindowChromeWorker.cs,de42dddb12b0ad8f
@@ -163,7 +163,7 @@ public void SetWindowCornerRadius(Window window, CornerRadius cornerRadius)
 
         Compositor compositor;
         Visual rootVisual;
-        if (!compositionContexts.TryGetValue(hWnd, out var compositionContext))
+        if (!_compositionContexts.TryGetValue(hWnd, out var compositionContext))
         {
             // we will need lots of hacks, let's go
             if (window.PlatformImpl?.GetType().GetField("_glSurface", BindingFlags.Instance | BindingFlags.NonPublic) is not { } glSurfaceField) return;
@@ -179,7 +179,7 @@ public void SetWindowCornerRadius(Window window, CornerRadius cornerRadius)
 
             compositor = Compositor.FromAbi(avaloniaCompositor.NativePointer);
             var target = DesktopWindowTarget.FromAbi(avaloniaTarget.NativePointer);
-            compositionContexts[hWnd] = compositionContext = new CompositionContext(compositor, rootVisual = target.Root);
+            _compositionContexts[hWnd] = compositionContext = new CompositionContext(compositor, rootVisual = target.Root);
 
             window.ScalingChanged += delegate
             {
@@ -194,7 +194,7 @@ public void SetWindowCornerRadius(Window window, CornerRadius cornerRadius)
             window.Closed += delegate
             {
                 compositionContext.Clip?.Dispose();
-                compositionContexts.Remove(hWnd);
+                _compositionContexts.Remove(hWnd);
             };
         }
         else
@@ -272,11 +272,11 @@ public unsafe void HideWindowWithoutAnimation(Window window)
         }
     }
 
-    private readonly Lock clipboardLock = new();
+    private readonly Lock _clipboardLock = new();
 
     public unsafe Task<WriteableBitmap?> GetClipboardBitmapAsync() => Task.Run(() =>
     {
-        using var _ = clipboardLock.EnterScope();
+        using var _ = _clipboardLock.EnterScope();
 
         if (!PInvoke.OpenClipboard(HWND.Null)) return null;
 

src/Everywhere/App.axaml.cs

@@ -6,7 +6,7 @@
 using Avalonia.Media.Imaging;
 using Everywhere.Enums;
 using Everywhere.Models;
-using Everywhere.Utils;
+using Everywhere.Utilities;
 using Everywhere.Views;
 using Everywhere.Views.Pages;
 using Microsoft.Extensions.DependencyInjection;

src/Everywhere/Entrance.cs

@@ -1,5 +1,5 @@
 #if !DEBUG
-using Everywhere.Utils;
+using Everywhere.Utilities;
 #endif
 
 using Serilog;

src/Everywhere/I18N/DynamicResourceKey.cs

@@ -1,7 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 using Avalonia.Controls;
 using Avalonia.Reactive;
-using Everywhere.Utils;
+using Everywhere.Utilities;
 using MessagePack;
 
 namespace Everywhere.I18N;

src/Everywhere/Models/ObjectObserver.cs

@@ -3,7 +3,7 @@
 using System.ComponentModel;
 using System.Reflection;
 using System.Text.Json.Serialization;
-using Everywhere.Utils;
+using Everywhere.Utilities;
 using ZLinq;
 
 namespace Everywhere.Models;

src/Everywhere/Models/Settings.cs

@@ -7,7 +7,7 @@
 using CommunityToolkit.Mvvm.ComponentModel;
 using Everywhere.Attributes;
 using Everywhere.Enums;
-using Everywhere.Utils;
+using Everywhere.Utilities;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using WritableJsonConfiguration;
@@ -29,11 +29,24 @@ public class Settings : ObservableObject
     [HiddenSettingsItem]
     public InternalSettings Internal { get; } = new();
 
-    private readonly DebounceHelper saveDebounceHelper = new(TimeSpan.FromSeconds(0.5));
-    private readonly Dictionary<string, object?> saveBuffer = new();
+    private readonly Dictionary<string, object?> _saveBuffer = new();
+    private readonly DebounceExecutor<Dictionary<string, object?>> _saveDebounceExecutor;
 
     public Settings(IConfiguration configuration)
     {
+        _saveDebounceExecutor = new DebounceExecutor<Dictionary<string, object?>>(
+            () => _saveBuffer,
+            saveBuffer =>
+            {
+                lock (saveBuffer)
+                {
+                    if (saveBuffer.Count == 0) return;
+                    foreach (var (key, value) in saveBuffer) configuration.Set(key, value);
+                    saveBuffer.Clear();
+                }
+            },
+            TimeSpan.FromSeconds(0.5));
+
         new ObjectObserver(HandleSettingsChanges)
             .Observe(Common, nameof(Common))
             .Observe(Behavior, nameof(Behavior))
@@ -42,17 +55,8 @@ public Settings(IConfiguration configuration)
 
         void HandleSettingsChanges(in ObjectObserverChangedEventArgs e)
         {
-            lock (saveBuffer) saveBuffer[e.Path] = e.Value;
-
-            saveDebounceHelper.Execute(() =>
-            {
-                lock (saveBuffer)
-                {
-                    if (saveBuffer.Count == 0) return;
-                    foreach (var (key, value) in saveBuffer) configuration.Set(key, value);
-                    saveBuffer.Clear();
-                }
-            });
+            lock (_saveBuffer) _saveBuffer[e.Path] = e.Value;
+            _saveDebounceExecutor.Trigger();
         }
     }
 }

…/Everywhere/Utils/AnonymousDisposable.cs …rywhere/Utilities/AnonymousDisposable.cssrc/Everywhere/Utils/AnonymousDisposable.cs renamed to src/Everywhere/Utilities/AnonymousDisposable.cs src/Everywhere/Utils/AnonymousDisposable.cs renamed to src/Everywhere/Utilities/AnonymousDisposable.cs

@@ -1,6 +1,6 @@
 using System.ComponentModel;
 
-namespace Everywhere.Utils;
+namespace Everywhere.Utilities;
 
 public class AnonymousDisposable(Action disposeAction) : IDisposable
 {
@@ -10,7 +10,7 @@ public void Dispose()
         disposeAction();
     }
 
-    public static AnonymousDisposable FromNotifyPropertyCHanged(INotifyPropertyChanged source, PropertyChangedEventHandler handler)
+    public static AnonymousDisposable FromNotifyPropertyChanged(INotifyPropertyChanged source, PropertyChangedEventHandler handler)
     {
         source.PropertyChanged += handler;
         return new AnonymousDisposable(() => source.PropertyChanged -= handler);

src/Everywhere/Utilities/DebounceExecutor.cs

@@ -0,0 +1,92 @@
+namespace Everywhere.Utilities;
+
+/// <summary>
+/// A high-performance, low-allocation debounced executor.
+/// It debounces calls to a parameterless method and, when the delay has passed,
+/// it invokes a value provider (Func{T}) and passes the result to an action (Action{T}).
+/// </summary>
+/// <typeparam name="T">The type of the value to be processed.</typeparam>
+public sealed class DebounceExecutor<T> : IDisposable
+{
+    private readonly Timer _timer;
+    private readonly Func<T> _valueProvider;
+    private readonly Action<T> _action;
+    private readonly TimeSpan _delay;
+
+    private volatile bool _isDisposed;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DebounceExecutor{T}"/> class.
+    /// </summary>
+    /// <param name="valueProvider">The function to call to get the value when the action is to be executed.</param>
+    /// <param name="action">The action to execute with the value from the provider.</param>
+    /// <param name="delay">The debounce delay time.</param>
+    public DebounceExecutor(Func<T> valueProvider, Action<T> action, TimeSpan delay)
+    {
+        _valueProvider = valueProvider;
+        _action = action;
+        _delay = delay;
+        // The state object is 'this' instance, passed to the callback.
+        _timer = new Timer(TimerCallback, this, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
+    }
+
+    /// <summary>
+    /// Triggers the execution of the action after the debounce delay.
+    /// If called again before the delay has passed, the timer is reset.
+    /// I've renamed Execute to Trigger, as it's a more fitting name for a parameterless method that starts a process.
+    /// </summary>
+    public void Trigger()
+    {
+        if (_isDisposed)
+        {
+            return;
+        }
+
+        // This is thread-safe. It will reset the timer to the specified delay.
+        _timer.Change(_delay, Timeout.InfiniteTimeSpan);
+    }
+
+    private static void TimerCallback(object? state)
+    {
+        // The callback runs on a ThreadPool thread.
+        var instance = (DebounceExecutor<T>)state!;
+        if (instance._isDisposed)
+        {
+            return;
+        }
+
+        try
+        {
+            // Get the value and execute the action.
+            var value = instance._valueProvider();
+            instance._action(value);
+        }
+        catch
+        {
+            // Depending on requirements, you might want to log exceptions here.
+            // By default, we suppress exceptions from the provider or action to prevent the timer from crashing.
+        }
+    }
+
+    /// <summary>
+    /// Disposes the executor, stopping any pending operations.
+    /// </summary>
+    public void Dispose()
+    {
+        if (_isDisposed)
+        {
+            return;
+        }
+        _isDisposed = true;
+
+        // Dispose the timer, which prevents any further callbacks.
+        // The WaitHandle ensures that we wait for any currently executing callback to complete.
+        using (var waitHandle = new ManualResetEvent(false))
+        {
+            if (_timer.Dispose(waitHandle))
+            {
+                waitHandle.WaitOne();
+            }
+        }
+    }
+}

src/Everywhere/Utils/DisposeCollector.cs …Everywhere/Utilities/DisposeCollector.cssrc/Everywhere/Utils/DisposeCollector.cs renamed to src/Everywhere/Utilities/DisposeCollector.cs src/Everywhere/Utils/DisposeCollector.cs renamed to src/Everywhere/Utilities/DisposeCollector.cs

@@ -1,14 +1,14 @@
 using System.Diagnostics.CodeAnalysis;
 
-namespace Everywhere.Utils;
+namespace Everywhere.Utilities;
 
 public class DisposeCollector<T>(bool enableDisposeOnFinalize = false) : IReadOnlyList<T>, IDisposable where T : IDisposable
 {
     public bool IsDisposed { get; private set; }
 
     public bool EnableDisposeOnFinalize { get; set; } = enableDisposeOnFinalize;
 
-    protected readonly List<T> disposables = [];
+    protected readonly List<T> _disposables = [];
 
     ~DisposeCollector()
     {
@@ -18,15 +18,15 @@ public class DisposeCollector<T>(bool enableDisposeOnFinalize = false) : IReadOn
     public T Add(T disposable)
     {
         if (IsDisposed) throw new ObjectDisposedException(nameof(DisposeCollector<>));
-        disposables.Add(disposable);
+        _disposables.Add(disposable);
         return disposable;
     }
 
     public T Add(Func<T> factory)
     {
         if (IsDisposed) throw new ObjectDisposedException(nameof(DisposeCollector<>));
         var disposable = factory();
-        disposables.Add(disposable);
+        _disposables.Add(disposable);
         return disposable;
     }
 
@@ -35,7 +35,7 @@ public void RemoveAndDispose(ref T? disposable)
         if (IsDisposed) throw new ObjectDisposedException(nameof(DisposeCollector<>));
         if (disposable == null) return;
         disposable.Dispose();
-        if (!disposables.Remove(disposable)) return;
+        if (!_disposables.Remove(disposable)) return;
         disposable = default;
     }
 
@@ -45,8 +45,8 @@ public void RemoveAndDispose(ref T? disposable)
     public void DisposeAndClear()
     {
         // 逆序释放，防止释放后的对象被再次使用
-        foreach (var disposable in disposables.Reversed()) disposable.Dispose();
-        disposables.Clear();
+        foreach (var disposable in _disposables.Reversed()) disposable.Dispose();
+        _disposables.Clear();
     }
 
     public void Dispose()
@@ -68,16 +68,16 @@ public static void DisposeToDefault(ref T? disposable)
 
     public IEnumerator<T> GetEnumerator()
     {
-        return disposables.GetEnumerator();
+        return _disposables.GetEnumerator();
     }
 
     IEnumerator IEnumerable.GetEnumerator()
     {
-        return ((IEnumerable)disposables).GetEnumerator();
+        return ((IEnumerable)_disposables).GetEnumerator();
     }
 
-    public int Count => disposables.Count;
-    public T this[int index] => disposables[index];
+    public int Count => _disposables.Count;
+    public T this[int index] => _disposables[index];
 }
 
 public class DisposeCollector(bool enableDisposeOnFinalize = false) : DisposeCollector<IDisposable>(enableDisposeOnFinalize)
@@ -94,7 +94,7 @@ public void RemoveAndDispose<T>(ref T? disposable) where T : IDisposable
     {
         if (IsDisposed) throw new ObjectDisposedException(nameof(DisposeCollector<>));
         if (disposable == null) return;
-        disposables.Remove(disposable);
+        _disposables.Remove(disposable);
         disposable.Dispose();
         disposable = default;
     }
@@ -105,12 +105,12 @@ public void Replace<T>([NotNullIfNotNull(nameof(newDisposable))] ref T? oldDispo
         if (oldDisposable != null)
         {
             oldDisposable.Dispose();
-            disposables.Remove(oldDisposable);
+            _disposables.Remove(oldDisposable);
         }
 
         oldDisposable = newDisposable;
         if (oldDisposable == null) return;
-        disposables.Add(oldDisposable);
+        _disposables.Add(oldDisposable);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]