Merge branch 'dev' into 250320BookmarkFavicon

Jack251970 · web-flow · commit ab34e83c5ea2 · 2025-04-09T16:41:28.000+08:00
diff --git a/Flow.Launcher.Core/Plugin/PluginManager.cs b/Flow.Launcher.Core/Plugin/PluginManager.cs
@@ -23,6 +23,8 @@ namespace Flow.Launcher.Core.Plugin
     /// </summary>
     public static class PluginManager
     {
+        private static readonly string ClassName = nameof(PluginManager);
+
         private static IEnumerable<PluginPair> _contextMenuPlugins;
 
         public static List<PluginPair> AllPlugins { get; private set; }
@@ -194,7 +196,7 @@ public static async Task InitializePluginsAsync()
             {
                 try
                 {
-                    var milliseconds = await Stopwatch.DebugAsync($"|PluginManager.InitializePlugins|Init method time cost for <{pair.Metadata.Name}>",
+                    var milliseconds = await API.StopwatchLogDebugAsync(ClassName, $"Init method time cost for <{pair.Metadata.Name}>",
                         () => pair.Plugin.InitAsync(new PluginInitContext(pair.Metadata, API)));
 
                     pair.Metadata.InitTime += milliseconds;
@@ -266,7 +268,7 @@ public static async Task<List<Result>> QueryForPluginAsync(PluginPair pair, Quer
 
             try
             {
-                var milliseconds = await Stopwatch.DebugAsync($"|PluginManager.QueryForPlugin|Cost for {metadata.Name}",
+                var milliseconds = await API.StopwatchLogDebugAsync(ClassName, $"Cost for {metadata.Name}",
                     async () => results = await pair.Plugin.QueryAsync(query, token).ConfigureAwait(false));
 
                 token.ThrowIfCancellationRequested();
diff --git a/Flow.Launcher.Core/Plugin/PluginsLoader.cs b/Flow.Launcher.Core/Plugin/PluginsLoader.cs
@@ -11,12 +11,17 @@
 #pragma warning restore IDE0005
 using Flow.Launcher.Infrastructure.UserSettings;
 using Flow.Launcher.Plugin;
-using Stopwatch = Flow.Launcher.Infrastructure.Stopwatch;
 
 namespace Flow.Launcher.Core.Plugin
 {
     public static class PluginsLoader
     {
+        private static readonly string ClassName = nameof(PluginsLoader);
+
+        // We should not initialize API in static constructor because it will create another API instance
+        private static IPublicAPI api = null;
+        private static IPublicAPI API => api ??= Ioc.Default.GetRequiredService<IPublicAPI>();
+
         public static List<PluginPair> Plugins(List<PluginMetadata> metadatas, PluginsSettings settings)
         {
             var dotnetPlugins = DotNetPlugins(metadatas);
@@ -59,8 +64,7 @@ private static IEnumerable<PluginPair> DotNetPlugins(List<PluginMetadata> source
 
             foreach (var metadata in metadatas)
             {
-                var milliseconds = Stopwatch.Debug(
-                    $"|PluginsLoader.DotNetPlugins|Constructor init cost for {metadata.Name}", () =>
+                var milliseconds = API.StopwatchLogDebug(ClassName, $"Constructor init cost for {metadata.Name}", () =>
                     {
                         Assembly assembly = null;
                         IAsyncPlugin plugin = null;
diff --git a/Flow.Launcher.Infrastructure/Image/ImageLoader.cs b/Flow.Launcher.Infrastructure/Image/ImageLoader.cs
@@ -7,15 +7,22 @@
 using System.Threading.Tasks;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
-using Flow.Launcher.Infrastructure.Logger;
+using CommunityToolkit.Mvvm.DependencyInjection;
 using Flow.Launcher.Infrastructure.Storage;
+using Flow.Launcher.Plugin;
 using SharpVectors.Converters;
 using SharpVectors.Renderers.Wpf;
 
 namespace Flow.Launcher.Infrastructure.Image
 {
     public static class ImageLoader
     {
+        // We should not initialize API in static constructor because it will create another API instance
+        private static IPublicAPI api = null;
+        private static IPublicAPI API => api ??= Ioc.Default.GetRequiredService<IPublicAPI>();
+
+        private static readonly string ClassName = nameof(ImageLoader);
+
         private static readonly ImageCache ImageCache = new();
         private static SemaphoreSlim storageLock { get; } = new SemaphoreSlim(1, 1);
         private static BinaryStorage<List<(string, bool)>> _storage;
@@ -51,15 +58,14 @@ public static async Task InitializeAsync()
 
             _ = Task.Run(async () =>
             {
-                await Stopwatch.NormalAsync("|ImageLoader.Initialize|Preload images cost", async () =>
+                await API.StopwatchLogInfoAsync(ClassName, "Preload images cost", async () =>
                 {
                     foreach (var (path, isFullImage) in usage)
                     {
                         await LoadAsync(path, isFullImage);
                     }
                 });
-                Log.Info(
-                    $"|ImageLoader.Initialize|Number of preload images is <{ImageCache.CacheSize()}>, Images Number: {ImageCache.CacheSize()}, Unique Items {ImageCache.UniqueImagesInCache()}");
+                API.LogInfo(ClassName, $"Number of preload images is <{ImageCache.CacheSize()}>, Images Number: {ImageCache.CacheSize()}, Unique Items {ImageCache.UniqueImagesInCache()}");
             });
         }
 
@@ -75,7 +81,7 @@ await _storage.SaveAsync(ImageCache.EnumerateEntries()
             }
             catch (System.Exception e)
             {
-                Log.Exception($"|ImageLoader.SaveAsync|Failed to save image cache to file", e);
+                API.LogException(ClassName, "Failed to save image cache to file", e);
             }
             finally
             {
@@ -170,8 +176,8 @@ private static async ValueTask<ImageResult> LoadInternalAsync(string path, bool
                 }
                 catch (System.Exception e2)
                 {
-                    Log.Exception($"|ImageLoader.Load|Failed to get thumbnail for {path} on first try", e);
-                    Log.Exception($"|ImageLoader.Load|Failed to get thumbnail for {path} on second try", e2);
+                    API.LogException(ClassName, $"|ImageLoader.Load|Failed to get thumbnail for {path} on first try", e);
+                    API.LogException(ClassName, $"|ImageLoader.Load|Failed to get thumbnail for {path} on second try", e2);
 
                     ImageSource image = ImageCache[Constant.MissingImgIcon, false];
                     ImageCache[path, false] = image;
diff --git a/Flow.Launcher.Infrastructure/Stopwatch.cs b/Flow.Launcher.Infrastructure/Stopwatch.cs
@@ -1,14 +1,11 @@
 ﻿using System;
-using System.Collections.Generic;
 using System.Threading.Tasks;
 using Flow.Launcher.Infrastructure.Logger;
 
 namespace Flow.Launcher.Infrastructure
 {
     public static class Stopwatch
     {
-        private static readonly Dictionary<string, long> Count = new Dictionary<string, long>();
-        private static readonly object Locker = new object();
         /// <summary>
         /// This stopwatch will appear only in Debug mode
         /// </summary>
@@ -62,36 +59,5 @@ public static async Task<long> NormalAsync(string message, Func<Task> action)
             Log.Info(info);
             return milliseconds;
         }
-        
-        
-
-        public static void StartCount(string name, Action action)
-        {
-            var stopWatch = new System.Diagnostics.Stopwatch();
-            stopWatch.Start();
-            action();
-            stopWatch.Stop();
-            var milliseconds = stopWatch.ElapsedMilliseconds;
-            lock (Locker)
-            {
-                if (Count.ContainsKey(name))
-                {
-                    Count[name] += milliseconds;
-                }
-                else
-                {
-                    Count[name] = 0;
-                }
-            }
-        }
-
-        public static void EndCount()
-        {
-            foreach (var key in Count.Keys)
-            {
-                string info = $"{key} already cost {Count[key]}ms";
-                Log.Debug(info);
-            }
-        }
     }
 }
diff --git a/Flow.Launcher.Plugin/Interfaces/IPublicAPI.cs b/Flow.Launcher.Plugin/Interfaces/IPublicAPI.cs
@@ -510,5 +510,31 @@ public interface IPublicAPI
         /// </param>
         /// <returns></returns>
         public Task UninstallPluginAsync(PluginMetadata pluginMetadata, bool removePluginSettings = false);
+
+        /// <summary>
+        /// Log debug message of the time taken to execute a method
+        /// Message will only be logged in Debug mode
+        /// </summary>
+        /// <returns>The time taken to execute the method in milliseconds</returns>
+        public long StopwatchLogDebug(string className, string message, Action action, [CallerMemberName] string methodName = "");
+
+        /// <summary>
+        /// Log debug message of the time taken to execute a method asynchronously
+        /// Message will only be logged in Debug mode
+        /// </summary>
+        /// <returns>The time taken to execute the method in milliseconds</returns>
+        public Task<long> StopwatchLogDebugAsync(string className, string message, Func<Task> action, [CallerMemberName] string methodName = "");
+
+        /// <summary>
+        /// Log info message of the time taken to execute a method
+        /// </summary>
+        /// <returns>The time taken to execute the method in milliseconds</returns>
+        public long StopwatchLogInfo(string className, string message, Action action, [CallerMemberName] string methodName = "");
+
+        /// <summary>
+        /// Log info message of the time taken to execute a method asynchronously
+        /// </summary>
+        /// <returns>The time taken to execute the method in milliseconds</returns>
+        public Task<long> StopwatchLogInfoAsync(string className, string message, Func<Task> action, [CallerMemberName] string methodName = "");
     }
 }
diff --git a/Flow.Launcher/App.xaml.cs b/Flow.Launcher/App.xaml.cs
@@ -21,7 +21,6 @@
 using Flow.Launcher.ViewModel;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
-using Stopwatch = Flow.Launcher.Infrastructure.Stopwatch;
 
 namespace Flow.Launcher
 {
@@ -35,6 +34,8 @@ public partial class App : IDisposable, ISingleInstanceApp
 
         #region Private Fields
 
+        private static readonly string ClassName = nameof(App);
+
         private static bool _disposed;
         private MainWindow _mainWindow;
         private readonly MainViewModel _mainVM;
@@ -136,7 +137,7 @@ public static void Main()
 
         private async void OnStartup(object sender, StartupEventArgs e)
         {
-            await Stopwatch.NormalAsync("|App.OnStartup|Startup cost", async () =>
+            await API.StopwatchLogInfoAsync(ClassName, "Startup cost", async () =>
             {
                 // Because new message box api uses MessageBoxEx window,
                 // if it is created and closed before main window is created, it will cause the application to exit.
@@ -313,7 +314,7 @@ protected virtual void Dispose(bool disposing)
                 _disposed = true;
             }
 
-            Stopwatch.Normal("|App.Dispose|Dispose cost", () =>
+            API.StopwatchLogInfo(ClassName, "Dispose cost", () =>
             {
                 Log.Info("|App.Dispose|Begin Flow Launcher dispose ----------------------------------------------------");
 
diff --git a/Flow.Launcher/PublicAPIInstance.cs b/Flow.Launcher/PublicAPIInstance.cs
@@ -31,6 +31,7 @@
 using Flow.Launcher.ViewModel;
 using JetBrains.Annotations;
 using Squirrel;
+using Stopwatch = Flow.Launcher.Infrastructure.Stopwatch;
 
 namespace Flow.Launcher
 {
@@ -431,6 +432,18 @@ public void InstallPlugin(UserPlugin plugin, string zipFilePath) =>
         public Task UninstallPluginAsync(PluginMetadata pluginMetadata, bool removePluginSettings = false) =>
             PluginManager.UninstallPluginAsync(pluginMetadata, removePluginSettings);
 
+        public long StopwatchLogDebug(string className, string message, Action action, [CallerMemberName] string methodName = "") =>
+            Stopwatch.Debug($"|{className}.{methodName}|{message}", action);
+
+        public Task<long> StopwatchLogDebugAsync(string className, string message, Func<Task> action, [CallerMemberName] string methodName = "") =>
+            Stopwatch.DebugAsync($"|{className}.{methodName}|{message}", action);
+
+        public long StopwatchLogInfo(string className, string message, Action action, [CallerMemberName] string methodName = "") =>
+            Stopwatch.Normal($"|{className}.{methodName}|{message}", action);
+
+        public Task<long> StopwatchLogInfoAsync(string className, string message, Func<Task> action, [CallerMemberName] string methodName = "") =>
+            Stopwatch.NormalAsync($"|{className}.{methodName}|{message}", action);
+
         #endregion
 
         #region Private Methods
diff --git a/Plugins/Flow.Launcher.Plugin.Explorer/ViewModels/SettingsViewModel.cs b/Plugins/Flow.Launcher.Plugin.Explorer/ViewModels/SettingsViewModel.cs
@@ -524,7 +524,7 @@ public string ExcludedFileTypes
             }
         }
 
-        public int MaxResultLowerLimit => 100;
+        public int MaxResultLowerLimit => 1;
         public int MaxResultUpperLimit => 100000;
 
         public int MaxResult
diff --git a/Plugins/Flow.Launcher.Plugin.Program/Main.cs b/Plugins/Flow.Launcher.Plugin.Program/Main.cs
@@ -13,7 +13,6 @@
 using Flow.Launcher.Plugin.SharedCommands;
 using Microsoft.Extensions.Caching.Memory;
 using Path = System.IO.Path;
-using Stopwatch = Flow.Launcher.Infrastructure.Stopwatch;
 
 namespace Flow.Launcher.Plugin.Program
 {
@@ -33,6 +32,8 @@ public class Main : ISettingProvider, IAsyncPlugin, IPluginI18n, IContextMenu, I
 
         internal static PluginInitContext Context { get; private set; }
 
+        private static readonly string ClassName = nameof(Main);
+
         private static readonly List<Result> emptyResults = new();
 
         private static readonly MemoryCacheOptions cacheOptions = new() { SizeLimit = 1560 };
@@ -189,7 +190,7 @@ public async Task InitAsync(PluginInitContext context)
 
             var _win32sCount = 0;
             var _uwpsCount = 0;
-            await Stopwatch.NormalAsync("|Flow.Launcher.Plugin.Program.Main|Preload programs cost", async () =>
+            await Context.API.StopwatchLogInfoAsync(ClassName, "Preload programs cost", async () =>
             {
                 var pluginCacheDirectory = Context.CurrentPluginMetadata.PluginCacheDirectoryPath;
                 FilesFolders.ValidateDirectory(pluginCacheDirectory);
@@ -256,6 +257,7 @@ static void MoveFile(string sourcePath, string destinationPath)
             });
             Context.API.LogInfo(ClassName, $"Number of preload win32 programs <{_win32sCount}>");
             Context.API.LogInfo(ClassName, $"Number of preload uwps <{_uwpsCount}>");
+
             var cacheEmpty = _win32sCount == 0 || _uwpsCount == 0;
 
             if (cacheEmpty || _settings.LastIndexTime.AddHours(30) < DateTime.Now)
@@ -332,12 +334,12 @@ public static async Task IndexProgramsAsync()
         {
             var win32Task = Task.Run(async () =>
             {
-                await Stopwatch.NormalAsync("|Flow.Launcher.Plugin.Program.Main|Win32Program index cost", IndexWin32ProgramsAsync);
+                await Context.API.StopwatchLogInfoAsync(ClassName, "Win32Program index cost", IndexWin32ProgramsAsync);
             });
 
             var uwpTask = Task.Run(async () =>
             {
-                await Stopwatch.NormalAsync("|Flow.Launcher.Plugin.Program.Main|UWPProgram index cost", IndexUwpProgramsAsync);
+                await Context.API.StopwatchLogInfoAsync(ClassName, "UWPProgram index cost", IndexUwpProgramsAsync);
             });
 
             await Task.WhenAll(win32Task, uwpTask).ConfigureAwait(false);

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,8 @@ namespace Flow.Launcher.Core.Plugin`
`23`	`23`	`/// </summary>`
`24`	`24`	`public static class PluginManager`
`25`	`25`	`{`
	`26`	`+ private static readonly string ClassName = nameof(PluginManager);`
	`27`	`+`
`26`	`28`	`private static IEnumerable<PluginPair> _contextMenuPlugins;`
`27`	`29`
`28`	`30`	`public static List<PluginPair> AllPlugins { get; private set; }`
`@@ -194,7 +196,7 @@ public static async Task InitializePluginsAsync()`
`194`	`196`	`{`
`195`	`197`	`try`
`196`	`198`	`{`
`197`		`- var milliseconds = await Stopwatch.DebugAsync($"\|PluginManager.InitializePlugins\|Init method time cost for <{pair.Metadata.Name}>",`
	`199`	`+ var milliseconds = await API.StopwatchLogDebugAsync(ClassName, $"Init method time cost for <{pair.Metadata.Name}>",`
`198`	`200`	`() => pair.Plugin.InitAsync(new PluginInitContext(pair.Metadata, API)));`
`199`	`201`
`200`	`202`	`pair.Metadata.InitTime += milliseconds;`
`@@ -266,7 +268,7 @@ public static async Task<List<Result>> QueryForPluginAsync(PluginPair pair, Quer`
`266`	`268`
`267`	`269`	`try`
`268`	`270`	`{`
`269`		`- var milliseconds = await Stopwatch.DebugAsync($"\|PluginManager.QueryForPlugin\|Cost for {metadata.Name}",`
	`271`	`+ var milliseconds = await API.StopwatchLogDebugAsync(ClassName, $"Cost for {metadata.Name}",`
`270`	`272`	`async () => results = await pair.Plugin.QueryAsync(query, token).ConfigureAwait(false));`
`271`	`273`
`272`	`274`	`token.ThrowIfCancellationRequested();`
Original file line number	Diff line number	Diff line change
`@@ -11,12 +11,17 @@`
`11`	`11`	`#pragma warning restore IDE0005`
`12`	`12`	`using Flow.Launcher.Infrastructure.UserSettings;`
`13`	`13`	`using Flow.Launcher.Plugin;`
`14`		`-using Stopwatch = Flow.Launcher.Infrastructure.Stopwatch;`
`15`	`14`
`16`	`15`	`namespace Flow.Launcher.Core.Plugin`
`17`	`16`	`{`
`18`	`17`	`public static class PluginsLoader`
`19`	`18`	`{`
	`19`	`+ private static readonly string ClassName = nameof(PluginsLoader);`
	`20`	`+`
	`21`	`+ // We should not initialize API in static constructor because it will create another API instance`
	`22`	`+ private static IPublicAPI api = null;`
	`23`	`+ private static IPublicAPI API => api ??= Ioc.Default.GetRequiredService<IPublicAPI>();`
	`24`	`+`
`20`	`25`	`public static List<PluginPair> Plugins(List<PluginMetadata> metadatas, PluginsSettings settings)`
`21`	`26`	`{`
`22`	`27`	`var dotnetPlugins = DotNetPlugins(metadatas);`
`@@ -59,8 +64,7 @@ private static IEnumerable<PluginPair> DotNetPlugins(List<PluginMetadata> source`
`59`	`64`
`60`	`65`	`foreach (var metadata in metadatas)`
`61`	`66`	`{`
`62`		`- var milliseconds = Stopwatch.Debug(`
`63`		`- $"\|PluginsLoader.DotNetPlugins\|Constructor init cost for {metadata.Name}", () =>`
	`67`	`+ var milliseconds = API.StopwatchLogDebug(ClassName, $"Constructor init cost for {metadata.Name}", () =>`
`64`	`68`	`{`
`65`	`69`	`Assembly assembly = null;`
`66`	`70`	`IAsyncPlugin plugin = null;`
Original file line number	Diff line number	Diff line change
`@@ -7,15 +7,22 @@`
`7`	`7`	`using System.Threading.Tasks;`
`8`	`8`	`using System.Windows.Media;`
`9`	`9`	`using System.Windows.Media.Imaging;`
`10`		`-using Flow.Launcher.Infrastructure.Logger;`
	`10`	`+using CommunityToolkit.Mvvm.DependencyInjection;`
`11`	`11`	`using Flow.Launcher.Infrastructure.Storage;`
	`12`	`+using Flow.Launcher.Plugin;`
`12`	`13`	`using SharpVectors.Converters;`
`13`	`14`	`using SharpVectors.Renderers.Wpf;`
`14`	`15`
`15`	`16`	`namespace Flow.Launcher.Infrastructure.Image`
`16`	`17`	`{`
`17`	`18`	`public static class ImageLoader`
`18`	`19`	`{`
	`20`	`+ // We should not initialize API in static constructor because it will create another API instance`
	`21`	`+ private static IPublicAPI api = null;`
	`22`	`+ private static IPublicAPI API => api ??= Ioc.Default.GetRequiredService<IPublicAPI>();`
	`23`	`+`
	`24`	`+ private static readonly string ClassName = nameof(ImageLoader);`
	`25`	`+`
`19`	`26`	`private static readonly ImageCache ImageCache = new();`
`20`	`27`	`private static SemaphoreSlim storageLock { get; } = new SemaphoreSlim(1, 1);`
`21`	`28`	`private static BinaryStorage<List<(string, bool)>> _storage;`
`@@ -51,15 +58,14 @@ public static async Task InitializeAsync()`
`51`	`58`
`52`	`59`	`_ = Task.Run(async () =>`
`53`	`60`	`{`
`54`		`- await Stopwatch.NormalAsync("\|ImageLoader.Initialize\|Preload images cost", async () =>`
	`61`	`+ await API.StopwatchLogInfoAsync(ClassName, "Preload images cost", async () =>`
`55`	`62`	`{`
`56`	`63`	`foreach (var (path, isFullImage) in usage)`
`57`	`64`	`{`
`58`	`65`	`await LoadAsync(path, isFullImage);`
`59`	`66`	`}`
`60`	`67`	`});`
`61`		`- Log.Info(`
`62`		`- $"\|ImageLoader.Initialize\|Number of preload images is <{ImageCache.CacheSize()}>, Images Number: {ImageCache.CacheSize()}, Unique Items {ImageCache.UniqueImagesInCache()}");`
	`68`	`+ API.LogInfo(ClassName, $"Number of preload images is <{ImageCache.CacheSize()}>, Images Number: {ImageCache.CacheSize()}, Unique Items {ImageCache.UniqueImagesInCache()}");`
`63`	`69`	`});`
`64`	`70`	`}`
`65`	`71`
`@@ -75,7 +81,7 @@ await _storage.SaveAsync(ImageCache.EnumerateEntries()`
`75`	`81`	`}`
`76`	`82`	`catch (System.Exception e)`
`77`	`83`	`{`
`78`		`- Log.Exception($"\|ImageLoader.SaveAsync\|Failed to save image cache to file", e);`
	`84`	`+ API.LogException(ClassName, "Failed to save image cache to file", e);`
`79`	`85`	`}`
`80`	`86`	`finally`
`81`	`87`	`{`
`@@ -170,8 +176,8 @@ private static async ValueTask<ImageResult> LoadInternalAsync(string path, bool`
`170`	`176`	`}`
`171`	`177`	`catch (System.Exception e2)`
`172`	`178`	`{`
`173`		`- Log.Exception($"\|ImageLoader.Load\|Failed to get thumbnail for {path} on first try", e);`
`174`		`- Log.Exception($"\|ImageLoader.Load\|Failed to get thumbnail for {path} on second try", e2);`
	`179`	`+ API.LogException(ClassName, $"\|ImageLoader.Load\|Failed to get thumbnail for {path} on first try", e);`
	`180`	`+ API.LogException(ClassName, $"\|ImageLoader.Load\|Failed to get thumbnail for {path} on second try", e2);`
`175`	`181`
`176`	`182`	`ImageSource image = ImageCache[Constant.MissingImgIcon, false];`
`177`	`183`	`ImageCache[path, false] = image;`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,6 @@`
`21`	`21`	`using Flow.Launcher.ViewModel;`
`22`	`22`	`using Microsoft.Extensions.DependencyInjection;`
`23`	`23`	`using Microsoft.Extensions.Hosting;`
`24`		`-using Stopwatch = Flow.Launcher.Infrastructure.Stopwatch;`
`25`	`24`
`26`	`25`	`namespace Flow.Launcher`
`27`	`26`	`{`
`@@ -35,6 +34,8 @@ public partial class App : IDisposable, ISingleInstanceApp`
`35`	`34`
`36`	`35`	`#region Private Fields`
`37`	`36`
	`37`	`+ private static readonly string ClassName = nameof(App);`
	`38`	`+`
`38`	`39`	`private static bool _disposed;`
`39`	`40`	`private MainWindow _mainWindow;`
`40`	`41`	`private readonly MainViewModel _mainVM;`
`@@ -136,7 +137,7 @@ public static void Main()`
`136`	`137`
`137`	`138`	`private async void OnStartup(object sender, StartupEventArgs e)`
`138`	`139`	`{`
`139`		`- await Stopwatch.NormalAsync("\|App.OnStartup\|Startup cost", async () =>`
	`140`	`+ await API.StopwatchLogInfoAsync(ClassName, "Startup cost", async () =>`
`140`	`141`	`{`
`141`	`142`	`// Because new message box api uses MessageBoxEx window,`
`142`	`143`	`// if it is created and closed before main window is created, it will cause the application to exit.`
`@@ -313,7 +314,7 @@ protected virtual void Dispose(bool disposing)`
`313`	`314`	`_disposed = true;`
`314`	`315`	`}`
`315`	`316`
`316`		`- Stopwatch.Normal("\|App.Dispose\|Dispose cost", () =>`
	`317`	`+ API.StopwatchLogInfo(ClassName, "Dispose cost", () =>`
`317`	`318`	`{`
`318`	`319`	`Log.Info("\|App.Dispose\|Begin Flow Launcher dispose ----------------------------------------------------");`
`319`	`320`
Original file line number	Diff line number	Diff line change
`@@ -524,7 +524,7 @@ public string ExcludedFileTypes`
`524`	`524`	`}`
`525`	`525`	`}`
`526`	`526`
`527`		`- public int MaxResultLowerLimit => 100;`
	`527`	`+ public int MaxResultLowerLimit => 1;`
`528`	`528`	`public int MaxResultUpperLimit => 100000;`
`529`	`529`
`530`	`530`	`public int MaxResult`